Vous êtes sur la page 1sur 76

MISE EN ŒUVRE

DE LA
MÉTHODE
DES
ÉLÉMENTS FINIS
R. HASSANI
2004 - 2005
_____________________________________________________________________________________________________________________________
Table des matières

Introduction .................................................................... p5

Partie A Rappels et généralités


A.1 L’approximation par éléments finis ............................................. p7
A.1.1 Bases de polynômes .............................................. p8
A.1.2 Élément réel, élément de référence et transformation géométrique ............. p8
A.2 Le problèmes type : la conduction de la chaleur en régime stationnaire .................. p 11
A.3 Discrétisation par éléments finis ............................................... p 12
A.4 Exemple d’un problème à inconnue vectorielle .................................... p 13

Partie B Mise en œuvre de la M.E.F


B.1 Organisation générale d’un code d’éléments finis .................................. p 17
B.2 Le pré-traitement : le maillage et l’organisation des données .......................... p 18
B.2.1 Description du mailleur « meshdel » ................................... p 18
B.2.2 Organisation des données .......................................... p 20
B.3 Une « petite librairie » d’éléments .............................................. p 27
B.3.1 Deux éléments linéiques (1D) ........................................ p 27
B.3.2 Deux éléments triangulaires (2D) ..................................... p 28
B.3.3 Deux éléments quadrilatéraux (2D) .................................... p 28
B.3.4 Un élément tétraédrique (3D) ........................................ p 29
B.3.5 Un élément hexaédrique (3D) ........................................ p 30
B.3.6 Calcul du jacobien et des dérivées cartésiennes .......................... p 30
B.3.7 Organisation de la librairie .......................................... p 32
B.3.8 Tests à réaliser .................................................. p 33
B.4 L’intégration numérique ..................................................... p 35
B.4.1 Formule d’intégration sur un segment .................................. p 35
B.4.2 Formule d’intégration sur un carré ..................................... p 35
B.4.3 Formule d’intégration sur un triangle ................................... p 36
B.4.4 Formule d’intégration sur un cube ..................................... p 36
B.4.5 Formule d’intégration sur un tétraèdre .................................. p 36
B.4.6 Organisation des routines liées à l’intégration ............................ p 37
B.4.7 Tests à réaliser .................................................. p 38
B.5 Le stockage de matrices creuses et la résolution de systèmes linéaires .................. p 39
B.5.1 Structure des systèmes linéaires issus de la M.E.F. ........................ p 39
B.5.2 Le stockage par ligne de ciel ......................................... p 40
B.5.3 Une routine de factorisation de matrices symétriques ....................... p 41
B.5.4 Organisation du « solveur » ......................................... p 41
B.5.5 Tests à réaliser .................................................. p 44
B.6 La procédure d’assemblage .................................................. p 45
B.6.1 Organisation du calcul des matrices et vecteurs élémentaires ................ p 46
B.6.2 Organisation de l’assemblage des matrices élémentaires .................... p 47
B.6.3 Tests à réaliser .................................................. p 47
B.7 Organisation générale du calcul du vecteur et de la matrice du système .................. p 49
B.7.1 Calcul d’une matrice et d’un vecteur élémentaire .......................... p 50
B.7.2 La prise en compte des conditions aux limites de type Dirichlet ............... p 51
B.7.3 Organisation générale ............................................. p 52
B.7.4 Remarques sur le calcul des charges surfaciques......................... p 54
B.7.5 Tests à réaliser .................................................. p 56
B.8 Le post-traitement : le calcul des grandeurs dérivées ................................ p 57
B.8.1 Le calcul des flux et des contraintes ................................... p 57
B.8.2 La visualisation des grandeurs tensorielles .............................. p 58

Partie C Ensemble de tests à réaliser au cours du développement


C.1 L’interpolation sur un élément de référence ....................................... p 61
C.2 Le calcul des dérivées cartésiennes ............................................ p 63
C.3 L’intégration numérique ..................................................... p 64
C.4 Le stockage par ligne de ciel ................................................. p 65
C.5 La décomposition LDU et la résolution .......................................... p 66
C.6 L’assemblage ............................................................ p 66
C.7 Le calcul des forces nodales ................................................. p 67
C.8 Des exemples complets ..................................................... p 68
Introduction

Ce cours se veut être un premier apprentissage de la mise en œuvre effective de la méthode des
éléments finis (M.E.F.). Le but n’est pas d’exposer tous les aspects que recouvre cette méthode et toutes
les particularités qu’elle peut présenter dans les différents domaines de la Physique et des Sciences de
l’Ingénieur. Au contraire, on a choisi une initiation par l’exemple en traitant un seul problème type : la
conduction de la chaleur.

Par une description détaillée des différentes étapes nécessaires à la programmation de cette méthode et
par une série de " travaux pratiques », on construit progressivement un code d’éléments finis. Chaque
étape est accompagnée par une suite de tests à réaliser en vue de la valider.
Moyennant quelques changements, le code final, on l’espère, pourra être adapté aux traitements de
problèmes différents de celui présenté ici. En particulier, certains aspects étudiés et programmés,
comme :

! l’utilisation d’un mailleur 2D, et la récupération des données liées aux maillages,
! le développement d’une librairie (plus ou moins riche) d’éléments,
! les techniques d’intégration numérique,
! l’utilisation de méthodes de résolution de systèmes linéaires et de stockage de matrices creuses,
seront directement réutilisables.

Les aspects théoriques (convergence, espaces fonctionnels, formulations variationnelles, etc.) de la


M.E.F. ne sont pas abordés. On renvoie aux différents cours théoriques du Master et aux ouvrages de
référence (tels que R. Dautray et J.L. Lions, Analyse mathématique et calcul numérique pour les sciences
et techniques, vol. 6, Masson ; P.A. Raviart et J.M. Thomas, Introduction à l’analyse numérique des
équations aux dérivées partielles, Masson ; P.G. Ciarlet, The finite Element Method for Elliptic
Problems, North Holland)

Dans la première partie, on trouvera un rapide rappel de la méthode et la présentation du problème


type. On y expose aussi à titre indicatif un problème à inconnue vectorielle : la déformation d’un solide
élastique, en montrant que les discrétisations des deux problèmes peuvent être mis sous une même
forme standard.
La deuxième partie est consacrée à la programmation des différentes étapes de la méthode.
La troisième partie présente la liste des tests à effectuer au cours du développement.

Références (disponibles à la B.U. ou sur internet)

Pour une première lecture, on peut conseiller les documents suivants


! G. Dhatt et G. Touzot : Une présentation de la méthode des éléments finis, Maloine, 1984.
(ce polycopié en est largement inspiré)
! B. Lucquin et O. Pironneau : Introduction au calcul scientifique, Masson, 1996.
! J. Garrigues : La méthode des éléments finis, 1999.
(petit cours disponible en différents formats sur internet : http://indy2.imt-mrs.fr/gar/ef.html)
Les ouvrages suivants demandent une connaissance plus approfondie mais restent abordables
! J.-L. Batoz et G. Dhatt : Modélisation des structures par éléments finis, Hermès, 1990.
! K.-J. Bathe : Finite Element Procedures, Prentice-Hall, 1996.
(Un grand classique. On y trouvera beaucoup de choses utiles à la mécanique des solides, des fluides
à la thermique, etc.)
PARTIE A
Rappels et généralités

A.1 L’approximation par éléments finis

Soit f une fonction définie sur un domaine ! " ! n (n = 1, 2 ou 3). Notons fk les valeurs qu’elle prend en
N points xk de ! arbitraires.
Si le calcul de f n’est pas évident, on peut chercher une approximation de f consistant à trouver une
fonction f plus facilement calculable et telle que les distances entre f et f aux points xk soient minimales
en un certain sens. Les N points de contrôle xk sont appelés les nœuds de l’approximation.
Si l’on choisit de minimiser le carré de la norme quadratique de l’écart ( ! k ( fk " fk )2 ) on aboutit à la
méthode des moindres carrés. Si l’on impose la nullité des N écarts fk ! fk on définit une approximation
(une interpolation) nodale ; les N valeurs fk sont alors appelées les variables nodales de
l’approximation.
Dans tous les cas il faut bien sûr s’imposer la forme mathématique de la fonction f . Si l’on choisit
classiquement une fonction polynomiale, on introduit M paramètres : les coefficients du polynôme.
Trouver la fonction approchée revient donc à déterminer ces M coefficients. Pour une approximation
nodale on choisira M = N, c’est à dire égalité entre le nombre d’inconnues et le nombre de données.
On conçoit alors que la construction de la fonction approchée soit lourde (et instable) si N est grand.
Pour contourner cette difficulté on découpe le domaine ! en sous-domaines !e contenant ne points de
contrôle (ne < N) ce qui permet de définir sur chacun d’eux une approximation nodale fe à un nombre
restreint de paramètres (mais non forcément limité aux seuls ne variables attachées aux nœuds de !e).
On nomme ce type d’approximation, approximation nodale par sous-domaines.
L’approximation par éléments finis est une approximation par sous-domaines, pour laquelle :
" La partition en sous-domaines et un recouvrement de ! sans recouvrement entre sous-domaines :
# ",
%
! = !!e , !e " !e ' = $ou un noeud, 'e ( e ',
%ou une arête,
&

" l’approximation sur chaque !e ne fait intervenir que les variables nodales attachées aux ne nœuds
que contient !e ,
" les fonctions approchées fe sont continues sur chaque !e,
" les valeurs fe (x p ) et fe ' (x p ) en un nœud xp commun aux deux sous-domaines !e et !e’ sont égales
(continuité de la fonction approchée).
Les sous-domaines !e munis de leur interpolation sont appelés éléments. L’union de ces éléments forme
le maillage du domaine.
Pour des raisons pratiques les sous-domaines ont des formes géométriques simples : triangles ou
quadrilatères en 2D, tétraèdres, prismes ou hexaèdres en 3D. De plus, les interpolations utilisées dans
les codes d’E.F. sont presque toujours polynomiales.
À l’époque où le découpage du domaine se faisait quasiment à la main et lorsque la géométrie du
domaine était complexe, il n’était pas rare (moyennant quelques règles de conformité) d’employer
différentes formes d’éléments dans le maillage. L’automatisation de la procédure de maillage, par le
développement de logiciels appropriés (les mailleurs), a raréfié cette habitude.
8

A.1.1 Bases de polynômes

On rappelle que l’espace P des polynômes de degré d est un espace vectoriel dont la dimension dépend
du degré d et du nombre de variables n. Par exemple, l’espace des polynômes d’une variable x et du
deuxième degré est un espace de dimension 3 dont la base canonique est constituée par les monômes 1,
x, x2.

Degr nbr. Dim(P) base canonique


é variables
1 2 1, x
1 2 3 1, x, y
3 4 1, x, y, z
1 3 1, x, x2
2 2 6 1, x, y, xy, x2, y2
3 10 1, x, y, z, xy, yz, zx, x2, y2, z2
1 4 1, x, x2, x3
3 2 10 1, x, y, xy, x2, y2, x2y, xy2, x3, y3
3 20 1, x, y, z, xy, yz, zx, x2, y2, z2, xyz, x2y, xy2, y2z, z2y, z2x, x2z, x3, y3, z3

Si ne désigne le nombre de nœuds dans un élément !e, alors l’interpolation polynomiale d’une fonction f
sur cet élément, s’écrit :
ne
f (x) = ! N i (x) fi , x !! n (n < ne),
i=1

où fi sont les valeurs de f prises aux nœuds et Ni sont des polynômes formant une ne"base de polynômes
et vérifiant :

N i (x k ) = ! ki , { }
i, k ! 1,...,ne ,

les xk étant les coordonnées des nœuds de !e. La construction de ces fonctions d’interpolation se fait à
partir de la base canonique de l’espace des polynômes de dimension ne et de la forme géométrique de
l’élément. On en donnera au §B.3 les expressions pour les éléments les plus utilisés.

Remarque : si dans un des espaces P on extrait une sous base de m polynômes, on engendre un sous espace de P de dimension m.
Par exemple, de la base quadratique (1, x, y, xy, x2, y2) on peut extraire la sous base bilinéaire constituée des monômes (1, x, y, xy)
engendrant un espace de dimension 4. On aura alors une interpolation plus pauvre que l’interpolation quadratique mais plus
riche que l’interpolation linéaire. C’est le cas, comme on le verra, des éléments quadrangulaires.

A.1.2 Élément réel, élément de référence et transformation géométrique

Les fonctions d’interpolation Ni sur un élément donné dépendent des coordonnées de ses nœuds. Leurs
expressions analytiques peuvent donc être « lourdes » à écrire. Pour palier à cet inconvénient et faciliter
le codage (mais aussi optimiser les temps de calcul), on introduit la notion d’élément de référence qui
n’est rien d’autre qu’un élément dont la forme (de même nature que l’élément réel) est donnée a priori.
La forme des éléments de référence a été standardisée :

" les éléments 1D ont pour élément de référence le segment {! ;" 1 # ! # 1},
" les éléments 2D ont pour élément de référence :
" le triangle {(!, "); 1 # ! # " $ 0, ! $ 0, " $ 0} pour les domaines triangulaires,
" le carré {(!, "); # 1 $ " $ 1, # 1 $ ! $ 1} } pour les domaines quadrilatères,
" les éléments 3D ont pour élément de référence :
" le tétraèdre {(!, ",# ); 1 $ ! $ " $ # % 0, ! % 0, " % 0, # % 0} pour les domaines tétraédriques,
" le cube {(!, ",# ); $ 1 % ! % 1, $ 1 % " % 1, $ 1 % # % 1} pour les domaines hexaédriques.
9

Ainsi par exemple, pour un élément triangulaire à 3 nœuds de coordonnées (x1 , y1 ), (x2 , y2 ) et (x3 , y3 ),
la fonction d’interpolation attachée au nœud (x1 , y1 ) a pour expression (S désigne l’aire du triangle)

N1 (x, y) = 1
2S
{(y 3 }
! y2 )(x2 ! x) ! (x3 ! x2 )(y2 ! y) .

Les deux autres fonctions sont obtenues par permutation circulaire des indices.
Si (!, ") désigne le correspondant de (x, y) sur l’élément de référence, ces fonctions d’interpolation ont
pour expression :
N1 (!, ") = 1 # ! # ", N 2 (!, ") = !, N 3 (!, ") = ",

où la transformation « élément réel # élément de référence » fait correspondre au nœud (x1 , y1 ) le nœud
(0,0), au nœud (x2 , y2 ) le nœud (1,0) et au nœud (x3 , y3 ) le nœud (0,1).

On voit donc sur cet exemple que l’expression des fonctions d’interpolation est plus simple et ne dépend
pas des coordonnées de l’élément réel, avantage qui est amplement utilisé dans les codes de calcul
sachant, qu’en pratique, ces fonctions ne sont calculées qu’en des points particuliers (les points
d’intégration) qui ont des positions xk fixées dans les éléments et ont donc le même correspondant $ k
dans l’élément de référence. Il s’ensuit que le calcul des fonctions d’interpolation n’a besoin d’être fait
qu’une seule fois et non autant de fois que d’éléments.

L’interpolation polynomiale sur un élément donné !e s’écrit alors (on note x = (x, y), ! = (!, ") ) :
ne
f (x) = " N i (! ) fi , avec x = !e ("),
i=1
où #e désigne la transformation géométrique élément de référence # élément réel.

Chaque transformation #e n’est évidemment pas unique, mais on lui impose :


" d’être bijective,
" de mettre en correspondance les nœuds de l’élément de référence et les nœuds de l’élément réel,
" de transformer la frontière de l’élément de référence en la frontière de l’élément réel.

Comme la majorité des mailleurs génèrent des éléments à frontière polynomiale (la plupart du temps
des segments de droite pour le 2D et des faces planes pour le 3D), on choisit une transformation
géométrique à base de polynômes. Elle s’écrit donc sous la même forme que l’interpolation nodale :
ne
x = !e (") = # N i (")xie , !x "#e .
i=1
Les fonctions polynomiales N i sont les fonctions de forme de l’élément. Si l’on choisit les mêmes
polynômes Ni que ceux utilisés pour l’interpolation nodale, on qualifie l’élément d’isoparamétrique.
C’est ce que l’on supposera dans la suite, même si ce choix n’est pas toujours justifié.

Exemple : le triangle réel dont les sommets (non alignés) ont pour coordonnées x1, x2, x3 est l’image du
triangle de référence par une application qui, si les côtés du triangle réel sont rectilignes, est une
affinité. La transformation s’écrit donc sous la forme :
x = F ! + c,
10
où F est une matrice 2%2 non dégénérée et c un vecteur constant. En imposant que xi = x(! i ) , i = 1, 2,
3, où les ! i sont les coordonnées des sommets de l’élément de références (c-à-d : (0,0), (1,0), (0,1) ), il
vient :
# 1& # 0&
x1 = F !1 + c = c, x2 ! x1 = F (" 2 ! "1 ) = F % ( , x3 ! x1 = F (" 3 ! "1 ) = F % ( ,
$ 0' $ 1'
ce qui montre que la première colonne de F est donnée par x2 ! x1 et la seconde par x3 ! x1 . La
transformation est donc :

x = (x2 ! x1 ) " + (x3 ! x1 ) # + x1 = (1 ! " ! #) x1 + " x2 + # x3

et on reconnaît bien les trois fonctions d’interpolation vues plus haut pour le triangle à 3 nœuds.
11

A.2 Le problème type : la conduction de la chaleur en régime stationnaire

On présente ici le problème qui nous servira d’exemple pour illustrer une des façons possibles d’aborder
un problème issu de la Physique en utilisant la méthode des éléments finis.
Après une description rapide des équations régissant le phénomène concerné (formulation forte), on
présente de manière heuristique (voir les cours théoriques pour plus de rigueur mathématique !) le
passage à une formulation variationnelle du problème (formulation faible). On aurait pu tout aussi bien
y parvenir par des considérations énergétiques, mais cela supposerait le lecteur familier avec la
physique du phénomène présenté.

On cherche la répartition T(x) de la température ainsi que le flux de chaleur dans un domaine ! " ! n
(où n est la dimension de l’espace physique : n = 1, 2 ou 3). On note ! = "# la frontière de ce domaine.
Les équations et données du problème, en régime stationnaire, sont :

a) L’équation de conservation de la chaleur, traduisant l’équilibre des flux : div(q) = r, où q !! n est le


vecteur flux de chaleur (quantité de chaleur traversant une surface unité par unité de temps. L’unité
S.I. du flux de chaleur est le W m-2) et r est l’apport de chaleur volumique (quantité de chaleur par
unité de volume et par unité de temps (unité S.I. : W m-3)), dû par exemple, à la désintégration
d’éléments radioactifs présents dans le milieu.

b) La loi de Fourier, loi empirique donnant une relation entre flux de chaleur et température :
q = !" #T, où $ est le tenseur de conductivité thermique (unité S.I. : W m-1 K-1) et exprime la
capacité qu’a le milieu à conduire la chaleur. Si le milieu est thermiquement isotrope alors $ = k I,
où I est le tenseur identité et k est le coefficient de conductivité thermique.

c) Les conditions aux limites :


" condition sur la température : T(x) = T(x), pour tout x !"T (condition de Dirichlet),
" condition sur le flux normal : q(x)T ! n(x) = "qn , pour tout x #$ q (condition de Neumann),
où !T " ! q = ! et n désignant la normale unitaire sortante à ! q (on a donc nT ! "#T = qn sur $ q ).

Remarques :
" Le problème en régime transitoire s’obtient en rajoutant au second membre de l’équation de conservation le terme %c&tT
traduisant l’inertie thermique du milieu (% : masse volumique, c : chaleur spécifique).
" Si le milieu est isotrope ($ = k I) et homogène (k indépendant de x) on obtient en injectant la loi de Fourier dans l’équation
d’équilibre, l’équation de Poisson : &T =' r / k.

Une formulation variationnelle du problème

On prend comme inconnue principale le champ scalaire T (formulation en température).


{ } {
On désigne par U adm = T : ! " !; T(x) = T(x) sur #T et par U 0 = T : ! " !; T(x) = 0 sur #T (pour la }
régularité du problème on peut supposer que Uadm et Uo sont inclus dans H 1 (!) ).
!
Soit alors T une fonction quelconque de U0 (fonction test, fonction de pondération,..). Multiplions
l’équation d’équilibre par cette fonction et intégrons sur tout le domaine :
!
# T (divq ! r) dV = 0.
"
! ! !
En remarquant que div(T q) = T divq + qT ! "T et en utilisant la formule de la divergence, on a :
! ! !
! $ qT "T dV + $Tq
T
n dS ! $ T r dV = 0.
# % #
!
En utilisant le fait que T = 0 sur !T , la condition aux limites sur le flux normal et la loi de Fourier, le
problème devient :
(trouver T !U adm telle que
* ! ! ! !
) % "T T #"T dV = % T qn dS + % T r dV , &T !U o .
*$
+ 'q $
12
A.3 Discrétisation par la méthode des éléments finis

Après avoir choisi une formulation variationnelle, il faut! choisir une approximation pour les fonctions
inconnues, ici! T et choisir les fonctions de pondération T. En effet, si l’on savait résoudre le problème
approché « !T » il s’ensuivrait que cette approximation est la solution exacte !
La méthode de Galerkin consiste à choisir les fonctions de pondération dans le même espace que la
fonction approchée. L’avantage pour le problème considéré ici est que l’on aboutit à un système
d’équations symétrique.

Soit donc un maillage constitué de nelem éléments possédant chacun nnode nœuds (on supposera
pour simplifier que le nombre de nœuds est le même pour tous les éléments).
On notera ndime la dimension de l’espace physique (1, 2 ou 3).

L’interpolation E.F. de T (afin de ne pas alourdir les notations on l’écrira encore T au lieu de la notation
classique Th) s’écrit sur un élément !e :
nnode
T(x) = ! N ie (x)Tie , pour tout x "#e ,
i=1
où les N ie sont les fonctions d’interpolation de l’élément !e ( N ie (x) = 0 si x !"e ) et les Tie , les valeurs
de T aux nnode nœuds de l’élément ( Tie = T(xie ) , xie étant les coordonnées des nœuds de ).
! ! nnode !
On choisit pour T le même type d’approximation (méthode de Galerkin) : T(x) = ! N ie (x)Tie .
i=1
!
Les gradients de T et de T , vecteurs de ! ndime sont donc donnés par
nnode ! nnode !
!T(x) = " Tie !N ie (x), !T(x) = " Tie !N ie (x).
i=1 i=1
La forme variationnelle discrète est alors :
nelem nnode ! +nnode / !
- -
& & Tie , & Tje % (!NieT "# !N je ) dV ' % Nier dV ' % Nie qn dS 0 = 0, 2Tie .
e=1 i=1 -. j =1 $e $e ($e )* q -1
La forme discrète s’écrit donc sous la forme :
nelem ! ! ! !e
{ }
# TeT ! keTe " fe = 0, $Te = (T1e ,..., Tnnode )T %" nnode ,
e=1

% !Ni
eT
où ke est une matrice de dimension nnode % nnode, de composantes (ke )ij = " #!N je dV , appelée
$e

matrice de rigidité (ou raideur) élémentaire et fe est un vecteur de dimension nnode, appelé vecteur
charge élémentaire et de composantes ( fe )i = " N ie r dV + " N ie qn dS.
!e #!e $% q
On voit donc que la forme variationnelle discrète globale se construit par sommation des formes
élémentaires. C’est cette nature répétitive des opérations qui a contribué au succès de la M.E.F.

La somme précédente peut se réorganiser sous la forme


! !
T T ! (K T " F ) = 0, #T $" nequa .
!
T , T et F sont des vecteurs de ! nequa (nequa est le nombre total de degrés de liberté, c’est-à-dire ici, le
nombre de nœuds dans le maillage moins le nombre de nœuds formant la frontière 'T) représentant,
respectivement, le vecteur global des températures nodales virtuelles, le vecteur global des
températures nodales, et le vecteur source global. K est la matrice de rigidité globale (de dimension
nequa % nequa).
!
Cette expression étant vraie pour tout T , le problème à résoudre est donc K T = F

La procédure consistant à passer des termes élémentaires ke et fe aux termes globaux K et F s’appelle
l’assemblage.
13
A.4 Exemple d’un problème à inconnue vectorielle et généralisation des
expressions de ke et fe

On prend comme exemple le problème de l’élasticité statique afin d’illustrer un problème où l’inconnue
est de nature vectorielle (ici le vecteur déplacement).
Ce qui suit n’est donné qu’à titre d’exemple. Le reste du document, notamment l’exposé des différentes
procédures numériques, n’étant consacré qu’au problème précédent. On montre toutefois que la
discrétisation de ce problème peut être mis sous une forme englobant aussi le problème thermique.
Ainsi un code basé sur cette écriture peut-il être utilisé aussi bien pour un problème thermique que
pour un problème d’élasticité.

On se place donc en petites déformations et on cherche le champ de déplacement ainsi que le champ de
contrainte dans un domaine ! " ! n composé d’un matériau ayant un comportement d’élasticité
linéaire. On note ' la frontière de ce domaine. Les équations et données du problème sont :

a) L’équation d’équilibre : div(! ) + f = 0 dans ! où ( désigne le tenseur des contraintes de Cauchy


(unité S.I.: Pa) et f la densité de force volumique (unité S.I.: N/m3). f peut représenter, par exemple,
les forces de pesanteur : f = (g où ( est la masse volumique et g est le vecteur accélération de la
pesanteur.
b) La loi d’élasticité linéaire : ! = C " dans ! où ) et le tenseur des déformations linéarisé et C est le
tenseur (du quatrième ordre) d’élasticité, indépendant de x si le milieu est homogène et dont les
coefficients s’expriment en fonction de 2 paramètres seulement si le milieu est isotrope (la loi
d’élasticité est alors la loi de Hooke).

c) La relation déformations - déplacements en petites déformations : ! = 1 2("u + "uT ).

d) Les conditions aux limites :


" sur le déplacement : u(x) = u(x), pour x !"u (condition de Dirichlet),
" sur le vecteur contrainte : ! (x) " n(x) = Fs (x), pour x #$! (condition de Neumann),
où ! u " ! # = ! , Fs est une densité de force surfacique (unité S.I. : N/m2) et n désigne la normale
unitaire à dirigée vers l’extérieur.

Remarques :
" L’équation du mouvement dans le cas de la dynamique s’obtient en rajoutant les forces d’inertie %)t2u au second membre de
l’équation d’équilibre (loi fondamentale de la dynamique).
" Les conditions aux limites peuvent être « mixtes » sur une portion de la frontière, à condition d’être cohérentes.

Une formulation variationnelle du problème


On prend comme inconnue principale le champ vectoriel u (formulation en déplacement).
{ } {
On désigne par U adm = u : ! " ! n; u(x) = u(x) sur # u et par U 0 = u : ! " ! n; u(x) = 0 sur # u (pour la }
régularité du problème on peut supposer que Uadm et U0 sont inclus dans ).
!
Soit alors u !U 0 un champ virtuel quelconque. On a alors :
!T
$ u ! (div(" ) + f ) dV = 0.
#
! ! !
En notant que div(! u) = uT div(! ) + "u : ! et en utilisant la formule de la divergence, on a :
! ! !
! $ "u : % dV + $ uT & % n dS + $ uT & f dV = 0.
# ' #
!
En utilisant la nullité de u sur ! u , la condition au limite sur le vecteur contrainte et la symétrie du
tenseur de Cauchy, le problème devient (c’est le principe des travaux virtuels) :
(trouver u !U adm tel que
* ! ! ! !
) " : # dV =
*$% % uT Fs dS + % uT f dV , 'u !U o ,
+ &# $

! ! ! !
où l’on a noté ! := ! (u) = 1 2("u + "uT ).
14

Cette écriture est valable pour toute loi de comportement. Si l’on fait intervenir le comportement
élastique on obtient finalement :

(trouver u !U adm tel que


* ! !T ! !
) " : C " dV =
* #$ $ u Fs dS + $ uT f dV , 'u !U o .
+ %& #

Discrétisation

On se place en 3D, puis on spécifiera les changements nécessaires pour le cas de l’élasticité plane.
L’interpolation E.F. du champ de déplacement sur un élément !e est donnée par
nnode
u(x) = (ux (x),uy (x),uz (x))T = ! N ie (x) uie ,
i=1

où uie !! ndime
(ndime = 3) est le vecteur déplacement au nœud i de l’élément e. On peut la réécrire sous
une forme condensée : u(x) = N e (x) ue , où Ne désigne la matrice de dimension ndime % nnode

N e = !" N1e I N 2e I e
..... N nnode I #$ ,
I est la matrice unité (ndime % ndime). Soit en 3D :
! Ne 0 0 N 2e 0 0 e
...... N nnode 0 0 $
# 1 &
Ne = # 0 N1e 0 0 N 2e 0 ...... 0 e
N nnode 0 &
# &
# 0
" 0 N1e 0 0 N 2e ...... 0 0 e
N nnode &
%

et ue est un vecteur de ! ndime!nnode contenant les déplacements aux nœuds de l’élément (on omet l’indice
e pour ne pas surcharger l’écriture) :
ue = (u1e ,u2e ,...,unnode
e
)T = (u1x ,u1y ,u1z; u2x ,u2y ,u2z;.....; unnode
x y
,unnode z
,unnode )T

Noter que le gradient du champ de déplacement, tenseur du second ordre, s’écrit !u = # i uie " !N ie .
Mais cette expression ne nous sera pas utile, car c’est le tenseur des déformations qui apparaît dans la
formulation variationnelle et qui lui est symétrique (donc 6 composantes indépendantes au lieu de 9).
D’autre part, comme il est plus commode de travailler avec des vecteurs qu’avec des matrices, rangeons
les 6 composantes de ) dans un vecteur :

e := (! xx , ! yy , ! zz ,2! xy ,2! yz ,2! zx )T


avec
2! kp = "kup + " puk , {
k, p # x, y, z . }
nnode
Ce vecteur s’écrit donc en fonction des déplacements nodaux : e = ! Bie uie , où les matrices Bie (6 % 3)
i=1
sont
" ! Ne 0 0 %
$ x i '
$ 0 ! y N ie 0 '
$ '
$ 0 0 ! z N ie '
e
Bi = $ '.
$ ! y N ie ! x N ie 0 '
$ '
$ 0 ! z N ie ! y N ie '
$ e
'
$# ! z N i 0 ! x N ie '&

On peut aussi employer une expression condensée : e(x) = Be (x) ue où ue a été défini plus haut et Be est
la matrice (6 % 3nnode)
Be = ! B1e B2e ..... Bnnode
e #.
" $
15

La loi de l’élasticité linéaire sera aussi écrite sous forme « vectorielle » :

s := (! xx , ! yy , ! zz , ! xy , ! yz , ! zx )T = D e,

avec D une matrice (6 % 6) qui fait intervenir les constantes d’élasticité et qui s’écrit pour le cas isotrope
(loi de Hooke) :
" 2µ + ! ! ! 0 0 0 %
$ '
$ ! 2µ + ! ! 0 0 0 '
$ '
! ! 2µ + ! 0 0 0 '
D=$ ,
$ 0 0 0 µ 0 0 '
$ '
$ 0 0 0 0 µ 0 '
$ 0 0 0 0 0 µ '&
#
où * et µ sont les coefficient de Lamé (*, µ > 0).

En résumé, nous avons :


" l’interpolation élément finis du champ de déplacement : u(x) = N e (x) ue (valable aussi pour le champ
!
u si l’on utilise la méthode de Galerkin),
" la relation déformation - déplacement dans cette approximation : e(x) = Be (x) ue ,
" la relation contrainte - déformation (loi de comportement linéaire) : s(x) = D . e(x),
" le produit contracté ! : " = ! xx ." xx + ! yy ." yy + ! zz ." zz + 2! xy ." xy + 2! yz ." yz + 2! zx ." zx qui intervient dans
la formulation variationnelle, et qui s’écrit simplement ici sT e.

Injectons ces différents ingrédients dans la formulation variationnelle pour obtenir la forme discrète :
nelem
#
!
{
ueT ! ke ue " fe = 0,} !
$ue %" ndime&nnode ,
e=1
avec
ke = " BeT D Be dV : la matrice de rigidité élémentaire, de dimension 3nnode % 3nnode,
!e

fe = " N eT f dV + " N eT Fs dS : le vecteur charge élémentaire, de dimension 3nnode


!e #!e $% &
! !
L’expression sous forme globale devient U T ! (K U " F ) = 0, #U $" nequa .

!
Étant vraie pour tout U , le système à résoudre est K U = F.

Le cas de l’élasticité plane

Deux cas sont à étudier, celui des déformations planes et celui des contraintes planes. On supposera
dans les deux cas que le domaine physique est dans le plan xOy.

1. Déformations planes : ! xz = ! yz = ! zz = 0.
Dans ce cas le tenseur des déformations se range dans un vecteur à 3 composantes indépendantes :

e = (! xx , ! yy ,2! xy )T .

! L’état de contrainte associé n’est en général pas plan car ! zz " 0 , mais cette composante se déduit
des deux autres composantes normales par la relation ! zz = " (! xx + ! yy ) où + est le coefficient de
Poisson. On pourra donc, dans les calculs, ranger ( dans un vecteur du même type que e :
s = (! xx , ! yy , ! xy )T . Il ne faudra pas cependant oublier cette composante hors plan, ! zz , dans le post-
traitement (notamment dans la représentation d’invariants de ( ).
16
La matrice D associée à la loi de Hooke est dans ce cas
" 2µ + ! ! 0 %
$ '
D=$ ! 2µ + ! 0 '.
$ '
$# 0 0 µ '&

Quant aux matrices déformation – déplacement, Bie (de dimension 3 % 2), elles s’écrivent
" ! Ne 0 %
$ x i '
Bi = $ 0
e
! y N ie '.
$ '
$ ! y N ie ! x N ie '
# &
La dimension de la matrice Be n’est donc plus que de 3 % 2nnode

2. Contraintes planes : ! xz = ! yz = ! zz = 0.
( et ) sont rangés comme précédemment dans des vecteurs à 3 composantes :
s = (! xx , ! yy , ! xy )T , e = (! xx , ! yy ,2! xy )T .

! L’état de déformation associé à un état de contrainte plan n’est pas en générale plan car ! zz " 0,
mais cette composante se déduit des deux autres composantes normales par la relation
! zz = "(# # + 2µ ) (! xx + ! yy ).
La matrice D associée à la loi de Hooke s’obtient en éliminant la composante hors plan )zz. Elle
s’écrit :
! A B 0 $
# & E
D=# B A 0 & avec A= et B = ! A,
# 0 0 µ & 1 ! "2
" %
E et * désignant le module de Young et le coefficient de Poisson, respectivement.

Remarque : uniformisation des expressions de ke et fe

Les matrices et vecteurs élémentaires des deux problèmes discrétisés par éléments finis peuvent se
mettre sous une forme unique :
ke = " BeT D Be dV et fe = " N eT f dV + " N eT Fs dS.
!e !e #!e $% &
Seules changent, selon le problème, les définitions des matrices Be, D et Ne. En effet, il est facile de voir
que l’on a pour le problème thermique :
" ! Ne ! Ne e
. . ! x N nnode %
$ x 1 x 2 '
D = $, e e e
N e = (N1 , N 2 ,..., N nnode ), $
Be = ! y N1 ! y N 2e
e e
. . ! y N nnode '.
$ '
$ ! z N1e ! z N 2e e
. . ! z N nnode '
# &
Si l’on désigne par

" ndofn le nombre de degrés de liberté par nœud (1 en thermique, ndime en élasticité),
" nevab le nombre de degrés de liberté par élément, c’est à dire le produit ndofn %nnode,
" nstri le nombre de composantes des grandeurs dérivées (ndime pour le flux thermique, 6 pour les
contraintes en élasticité 3D, 3 en élasticité plane),
les dimensions des divers vecteurs et matrices sont

" nevab % nevab pour ke, " nstri % nstri pour D,


" nevab pour fe, " ndofn % nevab pour Ne,
" nstri % nevab pour Be, " ndofn pour Fs et f.
PARTIE B
Mise en œuvre de la M.E.F.

B.1 Organisation générale d’un code d’éléments finis

L’organisation générale d’un code d’E.F. pour un problème stationnaire et linéaire se présente comme
suit :

Remarque : pour les problèmes transitoires et/ou non linéaires une (des) boucle(s) externe(s) aux bloc 3 et 4 sur les pas de temps
et/ou sur les pas de linéarisation est (sont) à rajouter.

La préparation des données se fait dans le bloc 1. Elle consiste en la définition du problème (lecture sur
fichier) :
! Propriétés matérielles et géométriques : nombre de sous-domaines à propriétés physiques
déterminées, valeurs de ces propriétés (par exemple module de Young E et coefficient de Poisson ! )
sur chaque sous-domaine (en général on les prend constantes par sous-domaine ou à répartition
spatiale prédéfinie par des fonctions simples).
! Conditions aux limites : valeurs imposées de l’inconnue (Dirichlet) et de ses dérivées (Neumann).
! Lecture d’un maillage du domaine : type de maille, coordonnées des nœuds et définition de chaque
élément ; liste des nœuds ou des arêtes (des faces en 3D) formant les parties de frontière où sont
imposées des conditions aux limites.
Cette étape sera étudiée au §B.2.
18

Le bloc 2 consiste, à partir des données de maillage (connections entre nœuds), à définir l’occupation
mémoire optimale de la matrice de rigidité et à organiser son stockage. Ce bloc est placé dans la
librairie d’algèbre linéaire. Ce problème de stockage sera étudié au §B.5.
Le bloc 3 représente le « noyau » du code d’E.F. Certaines de ces parties sont spécifiques au problème
traité, mais son organisation est générale. Comme les matrices et les vecteurs élémentaires nécessitent
le calcul d’intégrales sur les éléments, il est agencé autour de l’intégration numérique. On étudiera sa
structure au §B.7.
Les schémas d’intégration numérique associés à différents éléments de référence seront présentés au
paragraphe B.4 et la procédure d’assemblage au §B.5.
Le bloc 4, dont l’organisation est sensiblement la même que le bloc 3, concerne le calcul, sur chaque
élément, des grandeurs dérivées (flux de chaleur) une fois connue l’inconnue principale (température).
Le post-traitement et la représentation des résultats seront étudiés au §B.8.
La librairie d’éléments finis consiste en une suite de routines adaptées aux différents éléments et où
sont calculés :
! les fonctions de forme en un point quelconque de l’élément de référence,
! les dérivées locales (c-à-d, sur l’élément de référence) de ces fonctions,
! les positions dans l’élément de référence des points d’intégration et les poids associés,
! la matrice jacobienne du passage élément de référence " élément réel, son déterminant J, et les
dérivées cartésiennes des fonctions de forme.
Elle fait l’objet des paragraphes B.3 et B.4.
Enfin, dans la librairie d’algèbre linéaire, on placera des routines nécessaires à la gestion du stockage
de matrice, et des routines de factorisation et de résolution de systèmes linéaires.

Organisation de l’espace de travail

Sur un répertoire camef, on créera les répertoires suivants :


camef/source :
On y placera tous les fichiers sources. Il sera d’ailleurs préférable d’organiser les sources en
fichiers distincts. À titre indicatif, on pourra ranger toutes les routines de la librairie d’éléments
dans un fichier unique, libelem.f par exemple, celles d’algèbre linéaire dans un fichier
libalg.f, etc.
camef/tests :
On y développera des petits programmes ad hoc qui serviront à tester les différentes parties du
code au cours du développement

B.2 Le pré-traitement : le maillage et l’organisation des données

B.2.1 Description du mailleur « meshdel »

Ce logiciel est en fait composé de deux mailleurs bidimensionnels.


L’un est un mailleur topologique très rudimentaire permettant de découper en quadrilatères ou en
triangles tout domaine topologiquement équivalent à un carré. Le domaine peut être composé de sous
domaines à condition que chacun d’eux soit eux mêmes topologiquement équivalent à un carré. Les
maillages obtenus sont structurés mais peuvent avoir des mailles de taille variable.
L’autre, plus général, est basé sur la méthode de Delaunay et génère des maillages à base de triangles
pour des domaines à frontières polygonales quelconques. Les maillages obtenus sont alors non
structurés et permettent aussi une distribution variable de la taille de maille.
Dans chaque cas, des courbures prédéfinies par des fonctions simples (arc de cercle, polynômes, arc
d’ellipse, arc de sinus) peuvent être imposées à des portions de frontières.
Les éléments pouvant être générés par meshdel sont : le triangle à trois nœuds (T3), le triangle à six
nœuds (T6), le triangle à sept nœuds (T7), le quadrangle à quatre nœuds (Q4), le quadrangle à huit
nœuds (Q8) et le quadrangle à neuf nœuds (Q9). L’utilisation de ce mailleur sera étudiée en TP à
travers quelques exemples. Décrivons brièvement les données nécessaires à ce logiciel. Le fichier de
données se présente ainsi :
19
20

Le résultat est le maillage suivant

nbr d’élément : nelem = 952


nbr de nœuds : npoin = 497
nbr de nœuds par élément: nnode = 3
nbr de sous domaines : nmats = 1

nbr de « nœuds Dirichlet » : npntD = 22


nbr de « nœuds Neumann » : npntN = 0
nbr de « facettes Neumann » : nfacN = 10

Noter que pour les conditions aux limites de type Dirichlet seul compte la connaissance des nœuds où
les degrés de liberté seront imposés. Leur définition par face dans le fichier d’entrée n’est qu’une
commodité. D’où le résultat, en terme de nœuds uniquement, affiché ci-dessus. Au contraire, pour les
conditions de type Neumann, on distingue les charges distribuées (qu’il faudra donc intégrées sur les
surfaces où elles s’appliquent) et les charges ponctuelles. Cette distinction a besoin d’être connue par le
code d’éléments finis et est donc conservée par le mailleur. Les résultats sont présentés en terme de
faces d’éléments (ici 10) et de nœuds (ici 0).

B.2.2 Organisation des données

B.2.2.1 Coordonnées et table de connectivité

Un maillage est défini par les coordonnées de ses nœuds et la manière dont est défini chaque élément.
Le mailleur présenté plus haut générant un maillage où qu’un seul type d’élément est utilisé (pas de
mélange triangles - quadrangles ni mélange d’interpolations différentes), tous les éléments ont le même
nombre nnode de nœuds. Chaque élément est ainsi défini par la donnée de nnode numéros de nœud. On
appellera table de connectivité (ou de topologie) d’un élément la liste de ces numéros, notée lnods et de
dimension nnode # nelem. Par convention, cette liste est donnée en parcourant les nœuds de l’élément
dans le sens trigonométrique. Les coordonnées des nœuds sont rangées dans un tableau coord de
dimension ndime # npoin, où ndime est la dimension de l’espace (1, 2 ou 3) et npoin le nombre de nœuds
dans le maillage. Exemple :

Table de connectivité : Table des coordonnées :


coord(*,1) = (0,0)
élément 1 : lnods(*,1) = (1 6 5 3) coord(*,2) = (2,0)
élément 2 : lnods(*,2) = (4 5 6 2) coord(*,3) = (0,1)
coord(*,4) = (2,1)
ndime = 2 nnode = 4 coord(*,5) = (1,1)
nelem = 2 npoin = 6 coord(*,6) = (1,0)

Après utilisation de meshdel ces informations sont disponibles dans les fichiers xxxxxx.cnt de
connectivité et xxxxxx.cxy des coordonnées, où “xxxxxx” est le nom générique (à 6 lettres) du cas
étudié. Le premier travail de programmation est donc de lire ces deux fichiers et d’initialiser certaines
variables de dimensionnement.

B.2.2.2 Table des nœuds et des faces contraints

Les numéros des nœuds à degrés de liberté fixés (conditions de Dirichlet) sont listés dans une table
lpntD, leurs références dans une table lrefpD, toutes deux de dimension npntD.
De même, les numéros des nœuds où des charges concentrées seront appliquées (conditions de
Neumann) sont listés dans une table lpntN, leurs références dans une table lrefpN toutes deux de
dimension npntN.
21

Les numéros des nœuds formant les facettes d’éléments où des charges distribuées seront appliquées
(conditions de Neumann) sont rangés dans une table lfacN de dimension noeuf # nfacN où noeuf
désigne le nombre de nœuds sur les côtés des éléments (deux pour les éléments linéaires ou bilinéaires,
trois pour les éléments quadratiques). Les références attribuées à ces faces sont listées dans une table
lreffN de dimension nfacN.
Exemple :
Condition de Dirichlet Condition de Neumann

npntD = 2 npntN = 1
lpntD(1) = 2 lrefpD(1) = 1 lpntN(1) = 5 lrefpN(1) = 1
lpntD(2) = 4 lrefpD(2) = 1
noeuf = 2
nfacN = 2
lfacN(*,1) = (1 6) lreffN(1) = 1
lfacN(*,2) = (6 2) lreffN(2) = 2

Ces informations sont disponibles dans le fichier xxxxxx.lim.

B.2.2.3 Structure des fichiers xxxxxx.cnt, xxxxxx.cxy et xxxxxx.lim

Ci-dessous un aperçu de ces différents fichiers.


1) Fichier de connectivité xxxxxx.cnt
CONNECTIVITE DU MAILLAGE
nelem npoin ndime nsomt nnode npcon nface nmats npntD nfacN npntN
952 497 2 3 3 48 5 1 22 10 0
No.Elem No.Mat. (LNODS(i),i=1,nnode)
1 1 210 114 148
2 1 83 60 15
3 1 80 71 5
4 1 102 45 14
5 1 135 12 86
6 1 182 106 107
7 1 136 45 101
8 1 48 11 12
9 1 106 49 50
10 1 51 11 50
11 1 279 229 191
... . ... ... ...
... . ... ... ...
950 1 496 491 41
951 1 497 491 478
952 1 497 465 493

Notes :
! nsomt désigne le nombre de nœuds sommets dans l’élément (= nnode pour les éléments (bi ou tri)
linéaires),
! nmats est le nombre de sous domaines (nombre de matériaux),
! npcon et nface ne seront pas utilisés.

2) Fichier de coordonnées xxxxxx.cxy

COORDONNEES DES NŒUDS DU MAILLAGE


No.Nœud X Y
1 0.10000E+00 0.00000E+00
2 0.20000E+00 0.00000E+00
3 0.30000E+00 0.00000E+00
4 0.40000E+00 0.00000E+00
5 0.50000E+00 0.00000E+00
... ........... ...........
... ........... ...........
497 0.49547E+00 0.48915E+00
22

3) Fichier des conditions aux limites xxxxxxx.lim


CONDITIONS AUX LIMITES DE TYPE DIRICHLET
Nnœud
22
Num_Nœud Référence
30 1
31 1
32 1
33 1
.. .
.. .
8 2
9 2
10 2
CONDITIONS AUX LIMITES DE TYPE NEUMANN
Nface Nnœud
10 0
Liste des faces élémentaires
IP1 IP2 Ref.
20 21 1
21 22 1
22 23 1
23 24 1
24 25 1
25 26 1
26 27 1
27 28 1
28 29 1
29 30 1
liste des points source
(aucun)

B.2.2.4 Organisation de la préparation et de la lecture des données

On définira le problème à traiter (propriétés thermiques et conditions aux limites) ainsi que la
discrétisation associée par l’intermédiaire d’un fichier de paramètres qui sera lu par le programme
d’éléments finis.
Ce fichier de paramètres (xxxxxx.camef par exemple) pourra se présenter ainsi :
Nom générique des fichiers maillages (.cnt, .cxy, .lim)
therm1
NrefD NrefNp NrefNf . . . . (nbr de conditions aux limites dans chaque type)
2 1 2
Nipts . . . . . (nbr de points d’intégration à utiliser)
1
Propriétés thermiques de chaque matériaux (nmats lignes)
Ref_mat K r
1 3.0 1.0E-5
2 1.0 0.0E-5
Conditions aux limites – type Dirichlet (NrefD lignes)
Ref Température imposée
1 273.0
2 573.0
Conditions aux limites – type Neumann par point (NrefNp lignes)
Ref Source imposée
1 1E-2
Conditions aux limites – type Neumann par face (NrefNf lignes)
Ref Flux imposé
1 1E-3
2 1E-3

Description :
NrefD, NrefNp et NrefNf sont les nombres de références pour les conditions de Dirichlet, de Neumann
ponctuelles et de Neumann réparties, respectivement.
Nipts est le nombre de points d’intégration à utiliser dans chaque élément pour calculer
numériquement les intégrales associées aux matrices élémentaires et vecteurs élémentaires. Ce nombre
pourra être défini implicitement dans le code connaissant le type d’élément utilisé (information contenu
dans le fichier .cnt). Pour plus de souplesse, on a laissé le soin à l’utilisateur de le définir, mais cela
peut être “ dangereux ” (sous-intégration).
23

On développera deux routines de lecture.


La première fera la lecture et l’initialisation des paramètres entiers qui serviront aux dimensionnement
des différents tableaux dont on aura besoin. Elle lira donc en premier le nom générique des fichiers
maillage et procédera à leur ouverture. Puis fera la lecture :
- dans le fichier xxxxxx.cnt, de : nelem, npoin, ndime, nnode, nmats, npntD, nfacN, npntN,
- dans le fichier de paramètres, de : nrefD, nrefNp, nrefNf, nipts.
On initialisera dans cette routine les variables entières non lues suivantes :
noeuf : le nombre de nœuds par arêtes (en 2D). Ce nombre dépend du type d’élément donc de
ndime et de nnode.
ntotg : le nombre total de points d’intégration : ntotg = nipts # nelem
Une fois connues ces variables, différents tableaux pourront être alloués (allocation dynamique) dans le
programme principal.
La deuxième routine procédera à la lecture de la connectivité, des coordonnées, des conditions aux
limites et des propriétés de chaque matériaux, initialisera des tableaux utiles pour la suite et calculera
le nombre d’inconnues du problème. La liste de ces arguments avec leurs dimensions est donnée ci-
dessous

Tableaux à lire
lnods (nnode,nelem) :table de connectivité (lue dans xxxxxx.cnt)
matno (nelem) :numéros de matériau de chaque élément (lue dans xxxxxx.cnt)
coord (ndime,npoin) :table des coordonnées des nœuds (lue dans xxxxxx.cxy)
lpntD ( npntD) :liste des “nœuds de Dirichlet” (lue dans xxxxxx.lim)
lrefpD( npntD) :liste des références attribuées à ces nœuds (lue dans xxxxxx.lim)
lpntN ( npntN) :liste des “nœuds de Neumann” (lue dans xxxxxx.lim)
lrefpN( npntN) :liste des références attribuées à ces nœuds (lue dans xxxxxx.lim)
lfacN (noeuf,nfacN) :liste des nœuds formant chacune des “faces de Neumann” (lue dans
xxxxxx.lim)
lreffN( nfacN) : liste des références attribuées à ces faces (lue dans xxxxxx.lim)
props (2 ,nmats) : table contenant les valeurs des propriétés thermiques de chaque matériaux
(deux par matériau isotrope : K et r, lues dans le fichier de paramètres)

Tableaux à construire
Ces différents tableaux dont la construction va être détaillée sont les suivants :
Tfixe(npoin) : table contenant les éventuelles valeurs connues de T en chaque nœud du maillage
(construite à partir des informations lues dans le fichier de paramètres, de lpntD et
de lrefpD).
iffix(npoin) : table contenant les numéros assignés à chaque inconnue nodale (construite à partir
des informations lues dans le fichier de paramètres, de lpntD et de lrefpD).
forcc(npntN) : table contenant les valeurs des “ forces ” concentrées en chacun des “ nœuds de
Neumann ” (construite à partir des informations lues dans le fichier de paramètres,
de lpntN et de lrefpN).
charg(nfacN) : table contenant les valeurs des “ charges ” réparties sur chacune des “ faces de
Neumann ” (construite à partir des informations lues dans le fichier de paramètre,
de lfacN et de lreffN).

Variable à calculer
nequa : le nombre total d’équations (d’inconnues)

1) Description de la construction des tableaux iffix et Tfixe:


iffix est un tableau très important pour l’organisation du calcul éléments finis. Seuls sont numérotés
les d.d.l. non fixés. Ainsi si aucune condition de type Dirichlet n’est imposée, le nombre d’inconnues est
nequa = npoin et le d.d.l. associé au i-ème nœud du maillage reçoit le numéro d’inconnue i.
S’il y a npntD nœuds à T fixée, le nombre d’inconnues est nequa = npoin - npntD et les npntD
d.d.l. fixés ne doivent pas être numérotés.
24

On procédera ainsi :
Lire sur xxxxxx.lim : lpntD et lrefpD
Initialiser Tfixe et iffix à zéro
boucle de i = 1 à nrefD (pour chacune des références définie par
Lire sur le fichier de paramètre : l’utilisateur, lire le n° de cette référence,
iref, T et la valeur fixée de T)
boucle de j = 1 à npntD
jref = lrefpD(j) (parcourir les nœuds de Dirichlet jusqu'à
si (iref = jref) alors trouver ceux portant la référence iref)
inœud = lpntD(j) (numéro du nœud)
Tfixe(inœud) = T (stocker la valeur imposée à ce nœud)
iffix(inœud) = iffix(inœud) + 1 (mettre une valeur non nulle dans iffix)
fin_si
fin_boucle_j
fin_boucle_i

À la suite de ces opérations les d.d.l. fixés correspondent à des valeurs non nulles dans iffix.

Suggestion : il conviendrait de rajouter un test permettant d’envoyer un message d’erreur si une référence donnée par l’utilisateur
dans le fichier de paramètre n’est pas trouvée dans la liste lrefpD (incompatibilité entre le fichier de paramètres et les fichiers
maillage).

Remarque sur le calcul de Tfixe : Si un nœud se trouve à l’intersection de deux faces référencées, il
apparaît deux fois dans le fichier .lim. C’est le cas du nœud de coordonnées (0,0) du maillage en
triangles précédent. Ce nœud apparaît avec la référence 1 et avec la référence 2 (c’est pourquoi npntD =
22 et non 21).
Lorsqu’une telle situation se présente, l’utilisateur doit en être averti. À ce niveau, la valeur contenue
dans iffix en ce d.d.l. peut servir de test pour afficher un message et pour proposer une procédure :
faut-il faire la moyenne des deux valeurs imposées ? Faut-il en attribuer qu’une des deux ? La procédure
décrite ne garde qu’une des deux valeurs.

L’attribution des numéros d’inconnue à chaque d.d.l. et le calcul du nombre effectif d’inconnues se fait
alors très simplement dans ce deuxième bloc :
nequa = 0 (initialisation à zéro du nbr d’inconnues)
boucle de inœud = 1 à npoin (on parcourt tous les nœuds du maillage)
si(iffix(inœud) = 0) alors (si c’est un nœud libre :
nequa = nequa + 1 on a une inconnue de plus
iffix(inœud) = nequa on lui donne ce numéro)
sinon (si c’est un nœud fixé :
iffix(inœud) = 0 on ne lui attribue pas de numéro d’incconue)
fin_si
fin_boucle_inœud

Ainsi, par convention, une valeur nulle est attribuée aux nœuds à d.d.l. fixés ; ce qui sera, par la suite,
un moyen très simple de savoir si un nœud correspond à une inconnue ou à une donnée.

Alternative : un moyen plus économique consiste à placer dans iffix non pas une valeur nulle en cas de d.d.l. fixé mais une
valeur négative dont la valeur absolue correspond à la référence attribuée à ce d.d.l. La taille nécessaire du tableau Tfixe n’est
alors plus que de nrefD au lieu de npoin.

2) Description de la construction des tableaux forcc et charg


La procédure est très similaire à la procédure de construction de Tfixe :

Initialiser forcc et charg à zéro

construction de forcc :

boucle de i = 1 à nrefNp (boucle sur les références définies par l’utilisateur)


lire dans le fichier de paramètres : iref, F (n° de référence et valeur imposée)
boucle de j = 1 à npntN (boucle sur les npntN nœuds de Neumann)
jref = lrefNp(j) (référence du nœud)
si (iref = jref) alors (si sa référence correspond à celle lue :
forcc(j) = F stocker la valeur imposée)
fin_si
fin_boucle_j
fin_boucle_i
25

construction de charg :

boucle de i = 1 à nrefNf
lire dans le fichier de paramètres : iref, F
boucle de j = 1 à nfacN
jref = lrfNf(j)
si (iref = jref) alors
charg(j) = charg(j) + F
fin_si
fin_boucle_j
fin_boucle_i

Suggestion : ici aussi on suggère de placer des tests de compatibilité entre références définies dans le fichier de paramètres et
références existantes dans les fichiers issus du mailleur.
26
27

B.3 Une « petite librairie » d’éléments

Au cours du calcul E.F. on a besoin de calculer les fonctions de forme et leurs dérivées en un ensemble
de points ayant des positions fixées dans l’élément de référence (les points d’intégration).
Une fois choisis les éléments à utiliser, les fonctions de forme Ni et leurs dérivées $ % Ni par rapport aux
coordonnées locales de l’élément de référence peuvent donc être calculées en ces points une fois pour
toutes. Par contre, les dérivées $ xNi par rapport aux coordonnées cartésiennes font intervenir les
coordonnées de l’élément réel.

On se limite ici aux éléments de type Lagrange (continuité C o) où les variables nodales sont les valeurs
de la fonction inconnue. Pour les éléments de type Hermite (continuité C &, & >0), les valeurs des
dérivées de la fonction sont aussi variables nodales et la librairie doit être adaptée.

Dans ce qui suit, on donne, pour les éléments les plus utilisés, l’expression, sur l’élément de référence,
des fonctions d’interpolation et de leurs dérivées. Le calcul des dérivées cartésiennes fait l’objet du
§B.3.6.

B.3.1 Deux éléments linéiques (1D)

Le domaine de référence est le segment [!1,1].

B.3.1.1 Élément linéaire

Élément à deux nœuds dont la base polynomiale est formée des monômes 1, ".

nœud
1
2

B.3.1.2 Élément quadratique

Élément à trois nœuds dont la base polynomiale est formée des monômes 1, ", "2.

nœud
1
2
3
28

B.3.2 Deux éléments triangulaires (2D)

Le domaine de référence est le triangle 0 ! " ! 1, 0 ! # ! 1 $ ".

B.3.2.1 Élément linéaire

Élément à trois nœuds (les sommets du triangle) dont la base polynomiale est 1, ", #.

nœuds
1
2 0
3 0

B.3.2.1 Élément quadratique

Élément à six nœuds (les sommets et les milieux des cotés) dont la base est 1, ", #, "#, "2 , #2.

nœuds
1
2
3
4
5
6

B.3.3 Deux éléments quadrilatéraux (2D)

Le domaine de référence est le carré !1 " # " 1, ! 1 " $ " 1.

B.3.2.1 Élément bilinéaire

Élément à quatre nœuds (les sommets du carré). Avec quatre points il n’est pas possible d’avoir un
polynôme complet (cf. §A.1.1). On extrait une sous base des polynômes de degré 2 (base bilinéaire) : 1, ",
#, "#.
Les fonctions de forme sont obtenues en faisant le produit des fonctions de forme du segment linéaire
dans les deux directions :
29

nœuds
1
2
3
4

B.3.2.1 Élément quadratique

Élément à neuf nœuds (les sommets, les milieux des côtés et le centre). On utilise une approximation
quadratique dans les deux directions. La base est donc 1, ", #, "#, "2, #2, "2#, "#2, "2#2.
Les fonctions de forme sont obtenues en faisant le produit des fonctions de forme de l’élément
quadratique 1D.

B.3.4 Un élément tétraédrique (3D)

Le domaine de référence est le tétraèdre 1 ! " ! # ! $ % 0, " % 0, # % 0, $ % 0.

B.3.4.1 Élément linéaire

Élément à quatre nœuds (les sommets du tétraèdre) dont la base polynomiale est 1, %, ', (.

nœuds
1
2 0 0
3 0 0
4 0 0
30

B.3.5 Un élément hexaédrique (3D)

Le domaine de référence est le cube !1 " # " 1, ! 1 " $ " 1, ! 1 " % " 1.

B.3.5.1 Elément tri-linéaire

Élément à huit nœuds (les sommets de l’hexaèdre) dont la base polynomiale est une sous base de la
base des polynômes de degré 2 : 1, ", #, $. "#, "#, $", "#$.
Les fonctions de forme sont obtenues en faisant le produit des fonctions de forme de l’élément linéaire
1D dans les trois directions.

B.3.6 Calcul du jacobien et des dérivées cartésiennes

Les expressions des dérivées des fonctions de forme données au paragraphe précédent sont écrites par
rapport au système d’axes locaux (", #, $). Pour obtenir l’expression de ces dérivées par rapport au
système d’axes cartésiens (x, y, z), il faut faire intervenir la transformation géométrique qui permet de
passer de l’élément de référence à l’élément réel (cf. §A.1.2). Pour simplifier la présentation et la
structure du code, on supposera que les éléments sont tous isoparamétriques, même si cette hypothèse
est superflue dans les calculs que l’on fera avec certains éléments présentés ici (ex. : l’utilisation de
l’élément quadratique triangulaire à 6 nœuds à cotés droits, présenté au §B.3.2.1, ne nécessite en fait
qu’une approximation géométrique linéaire).

B.3.6.1 Matrice jacobienne pour un élément isoparamétrique

Soit % la transformation géométrique inversible et différentiable élément de référence & élément réel :

! : "r # " e
$ ! x = ! ($)

où ! = (!, ",# ) et x = (x, y, z). Considérons une fonction F : ! ! F(!) définie sur l’élément de référence et
soit f son expression sur l’élément réel : f (x) = (F ! ! "1 )(x).

Les dérivées de f par rapport à x, y, z sont alors données en fonction de celles de F par rapport à ", #, $ :

(! x f , !y f , !z f ) = (! F, ! F, ! F ) %&
" # $
'1
(x),
où est la matrice :
' $ x $ x $ x *
) # % &
,
!" (#) = ) $# y $% y $& y , =: J T
) ,
) $# z $% z $& z ,
( +
et qui représente le tenseur gradient de la transformation que l’on a rencontré en cours de mécanique
(et que l’on a noté F = !" ). On a noté J la matrice jacobienne.
Dans l’identité précédente, on reconnaît les transposés des vecteurs gradient de f et de F. On la réécrit
sous la forme :
! x f = J "1! # F
31

Bien entendu, la condition pour que la transformation soit inversible est que le jacobien soit non nul :
detJ ) 0.
Pour les éléments isoparamétriques, les coordonnées x d’un point quelconque d’un élément réel *e
s’obtiennent par interpolation de ses coordonnées nodales xie en utilisant les mêmes fonctions
d’interpolation Ni que l’approximation nodale :
nnode nnode nnode nnode
x= ! N i xie , y= ! N i yie , z= ! N i zie (ou x = ! N i xie ),
i=1 i=1 i=1 i=1
nnode
autrement dit, la transformation géométrique est définie par ! : " ! x = # N i (" ).xie
i=1
Les colonnes de la matrice J (ou les lignes de JT ) ne sont rien d’autre que les vecteurs gradient des
fonctions x(",#, $), y(", #, $) et z(", #, $) :
J = #$(! " x),(! " y),(! " z) %&
et s’obtiennent donc par :
nnode nnode nnode
!" x = # xie !" N i , !" y = # yie !" N i , !" z = # zie !" N i .
i=1 i=1 i=1

J s’écrit donc sous forme condensée :


nnode
J= # !" N i $ xie .
i=1

B.3.6.2 Dérivées cartésiennes des fonctions de forme

Si l’on considère maintenant les fonctions F(!) = N i (!) et f (x) = N i (x) on obtient, d’après ce qui
précède, l’expression des dérivées cartésiennes des fonctions de forme (i.e. ! x N i , ! y N i , ! z N i ) en
fonction des dérivées locales (i.e. !" N i , !# N i , !$ N i ) par :
'1
! x N i (x) = #$ J (" ) %& !" N i (" ).

Le procédé de calcul est donc simple : connaissant les coordonnées locales " du point x où l’on désire
calculer les dérivées cartésiennes et connaissant les coordonnées xie des nœuds de l’élément réel :

! calculer en ce point les dérivées locales ! Ni , "

nnode
! former la matrice jacobienne J = $ i=1 !" Ni # xie et l’inverser,
! calculer le produit J !1"# Ni .
Noter que les dimensions de la matrice jacobienne sont au plus 3 # 3. Un calcul manuel de son
déterminant et de sa matrice inverse pourra être explicitement codé :
On note Jij les éléments de la matrice J et J son déterminant.
1
! En dimension 1 : J !1 = , J = det J = J11 .
J
"
1 J 22 !J12 %
! En dimension 2 : J !1 = $ ', J = det J = J11J 22 ! J12 J 21 .
J
$# !J 21 J11 '&
" J 22 J33 ! J 23 J32 J13 J32 ! J12 J33 J12 J 23 ! J13 J 22 %
1$ '
! En dimension 3 : J !1
= $ J31J 23 ! J 21J33 J11J33 ! J13 J31 J 21J13 ! J 23 J11 ' ,
J$ '
$# J 21J32 ! J31J 22 J12 J31 ! J32 J11 J11J 22 ! J12 J 21 '&
J = det J = J11 (J 22 J33 ! J32 J 23 ) + J12 (J31J 23 ! J 21J33 ) + J13 (J 21J32 ! J31J 22 ).

Note : le jacobien detJ sera utilisé pour transformer les intégrales sur l’élément réel en intégrales sur
l’élément de référence (changement de variables).
32

B.3.7 Organisation de la librairie d’éléments

On organisera la partie de la librairie qui concerne l’interpolation et l’approximation géométrique en :


! un ensemble de routines de calcul des fonctions de forme et de leurs dérivées sur l’élément de
référence,
! un programme pilote qui contrôlera l’appel à la routine qui correspond au type d’élément utilisé,
! un programme de calcul du jacobien et des dérivées cartésiennes.
B.3.7.1 Le calcul des fonctions de forme et de leurs dérivées locales

! les routines élémentaires :


On donnera à chacune de ces routines un nom suffisamment explicite. Par exemple :
segment 2 nœuds element_Segm2 quadrangle 4 nœuds element_Quad4
segment 3 nœuds element_Segm3 quadrangle 8 nœuds element_Quad8
triangle 3 nœuds element_Tria3 tétraèdre 4 nœuds element_Tetr4
triangle 6 nœuds element_Tria6 hexaèdre 8 nœuds element_Hexa8

L’argument d’entrée :
Les coordonnées " où doivent être calculées les fonctions de forme et leurs dérivées.
L’argument de sortie :
les nnode fonctions de forme Ni et les ndime # nnode dérivées ! " N i au point " .

Synopsis :
element_Tria3 (x,y,shape,deriv)

shape(3), deriv(2,3)


x,y désigne les coordonnées (", #),
shape un tableau de réels contenant la valeur des fonctions de forme Ni,
deriv un tableau de réels contenant la valeur des dérivées ! " N i .

Par exemple, pour le triangle à 3 nœuds, cette routine aura la forme :

shape(1) = 1.0 - x - y deriv(1,1) =-1.0


shape(2) = x deriv(2,1) =-1.0
shape(3) = y
deriv(1,2) = 1.0
deriv(2,2) = 0.0

deriv(1,3) = 0.0
deriv(2,3) = 1.0

! le programme pilote :
Les arguments d’entrée :
La dimension de l’espace : ndime,
le nombre de nœuds de l’élément : nnode,
les coordonnées locales : " .
Les arguments de sortie :
Les nnode fonctions de forme Ni en " ,
les ndime # nnode dérivées premières ! " N i en " .

Dans les gros codes de calcul on utilise en général une nomenclature prédéfinie pour le type
d’élément. Une variable de type chaîne de caractères associée à tous les éléments du maillage définit
l’élément utilisé (exemple dans MODULEF : « TRIA 2P1D » et « QUAD 2Q1D » désignent
33

respectivement, le triangle linéaire à 3 nœuds et le quadrangle bilinéaire à 4 nœuds vus plus haut.
Dans CASTEM ces mêmes éléments sont désignés par « TRI3 » et « QUA4 »). On pourra faire de
même ici, ou plus simplement, du fait du peu d’éléments codés, se baser sur les combinaisons entre
la dimension de l’espace (ndime) et le nombre de nœuds par élément (nnode).

Synopsis :
Gshape (cdloc,shape,deriv,ndime,nnode)

cdloc(ndime), shape(nnode), deriv(ndime,nnode)

où cdloc est un tableau contenant les coordonnées locales (", #, $) du point où les Ni et ! " N i sont
demandés.
La structure de ce programme sera de la sorte :
si (ndime = 1) alors
x = cdloc(1)
si (nnode = 2) appel à element_Segm2 (x,shape,deriv)
si (nnode = 3) appel à element_Segm3 (x,shape,deriv)
fin_si
si (ndime = 2) alors
x = cdloc(1)
y = cdloc(2)
si (nnode = 3) appel à element_Tria3 (x,y,shape,deriv)
si (nnode = 4) appel à element_Quad4 (x,y,shape,deriv)
si (nnode = 6) appel à element_Tria6 (x,y,shape,deriv)
....
fin_si
....

B.3.7.2 Le calcul du jacobien et des dérivées cartésiennes

! Arguments d’entrée :
Les dérivées locales ! " N i (calculées en un point donné de l’élément),
les coordonnées des nœuds de l’élément réel xie,
la dimension de l’espace ndime et le nombre de nœuds nnode.
! Arguments de sortie :
Le jacobien det J au point considéré,
les dérivées cartésiennes ! x N i .

Synopsis :
jacob (deriv,cdnod,dcart,detjc,ndime,nnode)

deriv(ndime,nnode), cdnod(ndime,nnode), dcart(ndime,nnode)



cdnod est un tableau de réels contenant les coordonnées nodales xie de l’élément considéré
dcart est un tableau de réels contenant les dérivées cartésiennes grad x N i des fonctions Ni.
detjc est un réel représentant le déterminant det (J) le matrice jacobienne

La structure de cette routine a déjà été entrevue au §B.3.6.2 :


nnode
! calcul de la matrice jacobienne : J pq = " i=1 (xie )q ! p N i , p, q = 1,.., ndime,
! calcul de son déterminant et de son inverse de manière explicite (voir §B.3.6.2),
! calcul du produit J !1"# Ni .
Suggestion : il est souhaitable que jacob renvoie un indicateur d’erreur dans le cas où le jacobien est négatif ou nul.

B.3 8 Tests à réaliser

Pour l’interpolation et le calcul des dérivées locales : les tests C.1.1 et C.1.2.
Pour le calcul des dérivées cartésiennes : les tests C.2.1 et C2.2.
34
35

B.4 L’intégration numérique

La méthode des éléments finis demande le calcul d’intégrales sur chacun des éléments du maillage.
L’utilisation de la notion d’élément de référence permet, par changement de variables, de transformer
ces intégrales en intégrales sur un domaine fixe (l’élément de référence) :

" f (x) dV = " f ! # ($) det J ($) dV .


!e !r

Comme les éléments de référence ont été standardisés, les limites d’intégration sont connues une fois
pour toutes. Seul le jacobien det J fait intervenir les coordonnées de l’élément réel comme on l’a vu au
paragraphe précédent.
Le terme à intégrer pouvant être compliqué, il n’est pas toujours possible d’utiliser une intégration
analytique. On a alors recours à des intégrations numériques sur l’élément de référence :
nipts

# g(!) dV $ % g(! k ) &k,


"r k=1

où sont des points dans l’élément de référence associés à des poids ! k choisis de façon à assurer une
intégration exacte de polynôme de degré donné. Ces points sont les points d’intégration (exemple :
points de Gauss).
On donne ci-après, sans en donner de justifications (voir le Dhatt et Touzot, par exemple, d’où sont tirés
les tables ci-dessous), quelques formules d’intégration numérique pour les domaines de référence
classiques. Pour des formules d’ordre plus élevé consultez le livre cité.

B.4.1 Formule d’intégration sur un segment

Le domaine d’intégration est le domaine .

Les formules que l’on donne ici sont issues de la méthode de Gauss. Cette méthode consiste à
déterminer les nipts points d’intégration et poids associés de manière à intégrer exactement des
polynômes de degré d ' dmax avec dmax= 2 # nipts ( 1.

nipts ( " k) ( ) k) dmax


1 0 2 1
2 1 1 3
3 0 5

Autres formules disponibles dans le Dhatt et Touzot : formules d’ordre 5 (9 points d’intégration), d’ordre
6 (11 points) et formule d’ordre 7 (13 points). On y trouvera aussi la description de la méthode de
Newton-Cotes consistant à fixer a priori les coordonnées "k et à déterminer les poids )k.

B.4.2 Formule d’intégration sur un carré

Le domaine d’intégration est le domaine !1 " # " 1, ! 1 " $ " 1.

On utilise une intégration numérique à une dimension dans chaque direction ; on obtient la méthode
« produit » :
1 1

$ g(!, ") dV = $ d! $ g(!, ") d" & ( ' k ( ' l g(!k , "l ).
#r %1 %1 k l

Les coordonnées et les poids des points d’intégration sont, par exemple, ceux donnés au §B.4.1.
Autres formules disponibles dans le Dhatt et Touzot : formules utilisant une méthode directe.
36

B.4.3 Formule d’intégration sur un triangle

Le domaine d’intégration est le domaine ,

On utilise les formules de Hammer d’ordre m qui font partie des méthodes directes consistant à intégrer
de manière exacte des monômes ( ).
1 1% !
La formule d’intégration se met sous la forme $ g(!, ") dV = $ d! $ g(!, ") d" & ( ' k g(!k , "k ).
#r 0 0 k

Ordre nbr de coordonnées poids


m points nipts "k #k )k
1 1 1/3 1/3 1/2
1/2 1/2
2 3 0 1/2 1/6
1/2 0
1/3 1/3 9/80
a a A
1-2a a A
5 7 a 1-2a A
b b B
1-2b b B
b 1-2b B

6 + 15 4 155 + 15 31
avec a = , b= !a, A= et B = ! A.
21 7 2400 240
Autres formules disponibles dans le Dhatt et Touzot : formules d’ordre 3 (4 points d’intégration), d’ordre
4 (6 points) et d’ordre 6 (12 points).

B.4.4 Formule d’intégration sur un cube

Le domaine d’intégration est le domaine , ,

Comme pour le carré, on peut utiliser ici la méthode produit


1 1 1

% g(!, ",# ) dV = % d! % d" % g(!, ",# ) d# ' ( ( ( ) k ) l ) m g(!k , "l ,#m ).


$r &1 &1 &1 k l m

Les coordonnées et les poids des points d’intégration sont, par exemple, ceux donnés au §B.4.1.
Autres formules disponibles dans le Dhatt et Touzot : formules d’ordre 2, 3, 5 et 7 obtenues par une
méthode directe.

B.4.5 Formule d’intégration sur un tétraèdre

Le domaine d’intégration est le domaine

Comme pour le triangle, on utilise la méthode directe. La formule d’intégration se met sous la forme :
1 1& ! 1& ! & "

% g(!, ",# ) dV = % % % g(!, ",# ) d! d" d# ' ) ( k g(!k , "k ,# k ).


$r 0 0 0 k
37

Ordre nbr de coordonnées poids


m points nipts "k #k $k )k
1 1 1/4 1/4 1/4 1/6
a a a 1/24
2 4 a a b 1/24
a b a 1/24
b a a 1/24
1/4 1/4 1/4 !2/15
1/6 1/6 1/6 3/40
3 5 1/6 1/6 1/2 3/40
1/6 1/2 1/6 3/40
1/2 1/6 1/6 3/40

5! 5 5+3 5
avec a = , b= .
20 20
Autre formule disponible dans le Dhatt et Touzot : formule d’ordre 5 (15 points d’intégration).

B.4.6 Organisation des routines liées à l’intégration numérique

De manière à uniformiser les calculs, on présentera tous les schémas d’intégration sous la forme
générale
nipts

# g(!) dV $ S := % g(! k ) & k .


"r k=1

Pour les éléments carrés et cubiques, où la méthode produit est utilisée, on calculera donc les
coordonnées et les poids des points d’intégration par :

#%! k = (!q , ! p ) #%! k = (! p , !q , !r )


$ ou $ avec ! j " $% #1,1&' et ! j (j = p, q ou r) obtenus au §B.4.1.
&%" k = " p" q &%" k = " p" q" r

L’intégration numérique se réduit alors à une simple boucle :


S = 0.0
boucle de k = 1 à nipts
S = S + )k * g(% k)
fin_boucle_k

Les routines seront incluses dans la librairie d’éléments. On développera des routines élémentaires
donnant les % k et )k associés à chaque type de géométrie et un programme pilote contrôlant la bonne
routine à appeler suivant la dimension (ndime), le type d’élément (nnode et ndime) et la formule
d’intégration (nipts).

! Les routines élémentaires

On écrira une routine pour chaque géométrie, par exemple :

gauss_Segm pour le segment


gauss_Tria pour le triangle
gauss_Quad pour le quadrangle
gauss_Tetr pour le tétraèdre
gauss_Hexa pour l’hexaèdre

! Argument d’entrée :
Le nombre de points d’intégration.
! Arguments de sortie :
Les coordonnées et les poids des points d’intégration.
38

Synopsis :
gauss_? (cdpti,poids,nipts)

cdpti (n,nipts), poids(nipts)


n désigne la dimension de l’espace, explicitement connue à ce niveau,
cdpti est un tableau de réels contenant les coordonnées des points d’intégration,
poids est un tableau de réels contenant les poids associés.

Pour le cas de la méthode produit, utilisée pour le carré et le cube, un appel à gauss_Segm sera
utilisé dans les routines gauss_Quad et gauss_Hexa. Comme on prendra le même nombre de points
d’intégration dans chaque direction, il faudra veiller (+ test à faire lors de la lecture) à ce que le
nombre de points nipts soit un carré (cas 2D) ou un cube (cas 3D). La racine carré ou la racine
cubique de ce nombre sera passé en argument à gauss_Segm.
Une manière plus souple consisterait à laisser l’utilisateur choisir le nombre de points ni suivant
chaque direction (et alors nipts = ! ni ) mais la structure des données serait alors moins uniforme.
i

! Le programme pilote

! Arguments d’entrée :
Le nombre de points d’intégration,
la dimension de l’espace,
le nombre de nœuds par élément.
! Arguments de sortie :
Les coordonnées et les poids des points d’intégration.

Synopsis :
Ggauss (cdpti,poids,nipts,ndime,nnode)

cdpti (ndime,nipts), poids(nipts)

L’appel à la routine correspondante pourra se faire en fonction des arguments ndime et nnode qui,
vu le faible nombre d’éléments de notre librairie, définissent complètement le type d’élément. La
structure pourra être la suivante :

si (ndime = 1) appel à gauss_Segm

si (ndime = 2) alors
si (nnode = 3 ou nnode = 6) appel à gauss_Tria
si (nnode = 4 ou nnode = 8) appel à gauss_Quad
fin_si

si (ndime = 3) alors
si (nnode = 4) appel à gauss_Tetr
si (nnode = 8) appel à gauss_Hexa
fin_si

B.4.7 Tests à réaliser :

Il s’agit de tester les différents schémas avec des intégrations exactes : test C.3.
39

B.5 Le stockage de matrices creuses et la résolution de systèmes linéaires

B.5.1 Structure des systèmes linéaires issus de la M.E.F

Dans un système linéaire, Ax = b, on peut voir les relations entre inconnues xi sous forme d’un réseau
où l’on associe à chaque nœud i de ce réseau une inconnue xi qui sera en relation avec l’inconnue xj si le
nœud j appartient à la même maille. Considérons l’exemple simple suivant :

Dans ce réseau, l’inconnue attachée au nœud 1 est en relation avec


! elle même, d’où l’existence d’un terme a11,
! les inconnues attachées aux nœud 3, 5 et 6, d’où l’existence des termes a13, a15, et a16.
La structure de la matrice A sera donc la suivante (une croix désignant un terme non nul) :
" ! 0 ! 0 ! ! %
$ '
$ 0 ! 0 ! ! ! '
$ ! 0 ! 0 ! ! '
A=$ '.
$ 0 ! 0 ! ! ! '
$ ! ! ! ! ! ! '
$ ! ! ! ! ! ! '
# &

C’est exactement ce qui se passe pour les systèmes issus d’une discrétisation par élément finis : une
inconnue n’est en relation qu’avec les inconnues attachées aux nœuds voisins, d’où un nombre très
limité d’équations du système où apparaît cette inconnue et la présence de nombreux termes nuls dans
la matrice du système. Une telle matrice est dite creuse. Notons aussi que même si le système discrétisé
n’est pas symétrique, la matrice a une structure topologique symétrique (car s’il y a un terme aij cela
indique que le nœud i appartient à la même maille que le nœud j donc il y a aussi un terme aji).

Hauteurs de bande
La présence de nombreux zéros dans la matrice permet de ne pas avoir à stocker toute la matrice. Il
existe plusieurs méthodes de stockage, dont le stockage par ligne de ciel que l’on décrit au paragraphe
suivant. Disons simplement que l’efficacité du stockage (mais aussi de la résolution) est d’autant
meilleur que les termes non nuls sont regroupés autour de la diagonale. Le cas idéal (hormis le cas où la
matrice est diagonale !) est le cas où la matrice présente une structure par bandes avec un nombre de
bandes très faible par rapport à la dimension de la matrice :

on peut alors stocker uniquement les bandes.


On appelle hauteur de bande d’une colonne (resp., largeur de bande d’une ligne) la distance entre la
diagonale et le dernier terme non nul de cette colonne (resp., ligne). Par exemple, pour la matrice B ci-
dessus chaque colonne (sauf la première) a une hauteur de bande de 1, tandis que pour la matrice A, la
colonne 2 a une hauteur de 0, la 3e et la 4e une hauteur de 2, la 5e une hauteur de 4 et la 6e une hauteur
de 5.
La hauteur de bande (resp. la largeur de bande) d’une matrice est alors la plus grande hauteur de
bande de ses colonnes (resp. de ses lignes).

Optimisation de la numérotation
Les termes non nuls seront d’autant plus regroupés autour de la diagonale que cette hauteur sera faible
et le stockage efficace. Pour diminuer la hauteur de bande, donc diminuer la place nécessaire au
stockage, il est parfois utile de réorganiser les équations du système. Pour les matrices issues d’un
calcul par élément finis cela correspond à une réorganisation de la numérotation des nœuds du
maillage.
40

Reprenons l’exemple du réseau précédent en modifiant la numérotation des nœuds (donc des
inconnues) :

La matrice, traduisant les relations entre inconnues, aura l’allure suivante


" ! ! ! ! 0 0 %
$ '
$ ! ! ! ! 0 0 '
$ ! ! ! ! ! ! '
$ '.
$ ! ! ! ! ! ! '
$ 0 0 ! ! ! ! '
$ 0 0 ! ! ! ! '
# &
Les termes non nuls sont, avec cette nouvelle numérotation, mieux regroupés autour de la diagonale ;
les hauteurs de colonnes sont effectivement :
colonne 2 : 1
colonne 3 : 2
colonne 4 : 3
colonne 5 : 2
colonne 6 : 3
donc, une hauteur de bande de 3 au lieu de 5.
Pour un maillage donné, il existe une numérotation optimale (pas toujours unique) assurant un
stockage minimal. On voit sur cet exemple, que pour trouver la numérotation optimale, il faut s’assurer
que la différence entre numéros d’inconnue soit la plus petite possible dans chaque maille.
Il existe quelques méthodes d’optimisation de numérotation. Le mailleur « meshdel » que vous utiliserez
est équipé d’une telle procédure assurant une occupation mémoire optimale (l’optimiseur est activé en
donnant à la variable IOPTN la valeur 1).

B.5.2 Le stockage par ligne de ciel

Reprenons la matrice de l’exemple précédent


! a 0 a13 0 a15 a16 $
# 11 &
# 0 a22 0 a24 a25 a26 &
# &
a 0 a33 0 a35 a36 &
A = # 31 .
# 0 a42 0 a44 a45 a46 &
# &
# a51 a52 a53 a54 a55 a56 &
# a
" 61 a62 a63 a64 a65 a66 &%
Les hauteurs des colonnes sont :
h1 = 0, h2 = 0, h3 = 2, h4 = 2, h5 = 4, h6 = 5.
Les largeurs des lignes ont les mêmes valeurs, la matrice ayant une topologie symétrique :
b1 = 0, b2= 0, b3 = 2, b4 = 2, b5 = 4, b6 = 5.
L’enveloppe des sommets des colonnes est appelée ligne de ciel (en pointillés sur le dessin).
Le stockage par ligne de ciel consiste à stocker les colonnes de longueurs variables (et les lignes, si A
n’est pas symétrique) les unes après les autres. On utilise pour cela un tableau Acol dans lequel on
range les différents termes par colonne descendante (par exemple) :

(
Acol = a11 / a22 / a13 ,0, a33 / a24 ,0, a44 / a15 , a25 , a35 , a45 , a55 / a16 , a26 , a36 , a46 , a56 , a66 )
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

et un tableau Alig similaire pour les lignes si la matrice n’est pas symétrique (dans ce cas, on perd un
peu de place car les termes de la diagonale sont stockés deux fois. Pour éviter cela, on peut utiliser trois
tableaux : dans l’un on range les termes de la diagonale et dans les deux autres on range les colonnes et
lignes « strictes »).
41

Dans le tableau Acol, les termes de la diagonale sont placés en fin de colonne. Leurs positions
marquent donc la fin de chaque colonne (ou le début de la suivante). La connaissance des ces adresses
est donc nécessaire pour le stockage et pour la gestion de la matrice. On les range dans une table :
idiag = (1, 2, 5, 8, 13, 19).
La position dans Acol de n’importe quel terme aij de la matrice est complètement définie par la
connaissance de cette table idiag. En effet, considérons par exemple le 3e terme de la 5e colonne (a35), il
est placé en 11e position dans Acol. Le dernier terme de sa colonne (a55) est placé en idiag(5) = 13e
position dans Acol ; il faut donc à partir de cette position remonter la colonne de 2 (= 5 ! 3) termes
pour arriver à a35.
Donc,

! la position dans Acol du terme aij (j " i) intérieur à la ligne de ciel est m = idiag(j)! (j!i)

Pour la matrice de cet exemple, le stockage par ligne de ciel nécessite (si A est symétrique) le stockage
de 19 réels et de 6 entiers, au lieu des 36 réels que nécessiterait le stockage complet. Si l’on avait utilisé
la numérotation optimale présentée au paragraphe précédent, le nombre de termes dans Acol aurait
été de 17.

Note : remarquez que le dernier terme de idiag donne la taille du tableau Acol.

B.5.3 Une routine de factorisation de matrices symétriques

La matrice de rigidité K du problème type est symétrique (elles est même définie positive) ce qui est le
cas d’une large classe de problèmes issus de la Physique. La résolution finale nécessite l’inversion d’un
système linéaire K U = F. Diverses méthodes numériques existent et font l’objet de nombreux ouvrages
de base d’analyse numérique. On ne s’étendra donc pas sur ce thème. Précisons seulement qu’il est
nécessaire d’adapter un algorithme de résolution de systèmes linéaires au cas de matrices stockées par
ligne de ciel.
À cette fin, une routine de factorisation sous forme LDU où L est une matrice triangulaire inférieure, U
une matrice triangulaire supérieure (U = LT) et D une matrice diagonale vous sera remise ainsi qu’une
routine de résolution du système ainsi décomposé.

B.5.4 Organisation du « solveur »

On entend ici par « solveur » l’ensemble des procédures de manipulation de matrices. On le présentera
comme un recueil de routines d’algèbre linéaire. Il comprendra :
! des routines liées à la gestion du stockage,
! une routine de factorisation de matrices symétriques stockées par ligne de ciel,
! une routine de résolution de systèmes linéaires,
! éventuellement, des routines de calcul de valeurs et vecteurs propres.
B.5.4.1 Organisation des routines liées au stockage par ligne de ciel

Pour simplifier la présentation on ne traitera que le cas où A est symétrique, l’extension au cas non
symétrique étant évidente.
On note par nequa le nombre utile d’équations (c’est-à-dire, pour un problème à inconnue scalaire,
nequa = npoin ! N, où npoin désigne le nombre total de noeuds dans le maillage et N le nombre de
nœuds où l’inconnue est fixée). Les dimensions de la matrice A du système sont donc nequa # nequa.
L’espace nécessaire au stockage de A par ligne de ciel (taille du tableau Acol) est noté nesky.
On a vu au §B.5.1 que la structure topologique de la matrice dépend uniquement de la connectivité du
maillage. Cette connectivité est définie par la table lnods (voir §B.2) donnant la liste des nœuds de
chaque élément du maillage. Les hauteurs des colonnes et l’occupation mémoire pourront donc être
déterminées immédiatement après lecture du maillage.
42

On rappelle (§B.2) que les numéros d’inconnue (1,..., nequa) des degrés de liberté sont rangés dans un
tableau iffix de dimension npoin. Ainsi, le degré de liberté associé au noeud Ipoin a pour numéro
d’inconnue :
Iinc = iffix (Ipoin),
numéro qui, par convention, est nul si la valeur de ce d.d.l. est imposée.
On développera :
! une routine qui permet d’extraire les nnode numéros des d.d.l. d’un élément donné (table de
localisation élémentaire). Elle nous servira dans le calcul des hauteurs des colonnes, mais aussi lors
de l’assemblage (§B.6),
! une routine déterminant les hauteurs des colonnes de la matrice A, les adresses dans le tableau Acol
des termes diagonaux et la taille nesky de ce tableau.

! construction de la table de localisation élémentaire (locel)

Exemple : Considérons le maillage formé par les deux éléments à quatre nœuds suivant

Désignons par Ti=1,...,6 les variables attachées à ces noeuds, et supposons, par exemple, que le degré
de liberté attaché au nœud 4 est fixé (T4 est donné). Les inconnues sont rangées dans une table X :

X = (T1 ,T2 ,T3 ,T5 ,T6 ).

La table de connectivité est :


! pour l’élément 1 : lnods (*,1) = (1, 6, 5, 3),
! pour l’élément 2 : lnods (*,2) = (6, 2, 4, 5).

Le tableau iffix, qui réalise la correspondance entre les d.d.l. et les numéros d’inconnue est ici

N° nœud 1 2 3 4 5 6
iffix = 1 2 3 0 4 5 n° d.d.l

Les variables attachées aux éléments sont :


! pour l’élément 1 : T1, T6, T5, T3 d’où locel = (1, 5, 4, 3),
! pour l’élément 2 : T6, T2, T4, T5 d’où locel = (5, 2, 0, 4).

Structure de la routine :

! Arguments d’entrée :
La liste des nœuds de l’élément,
le nombre de nœuds de l’élément,
le nombre de nœuds dans le maillage.
! Argument de sortie :
La liste des numéros d’inconnue des d.d.l. de l’élément.

Synopsis :
locelem (noeud,iffix,locel,nnode,npoin)

noeud(nnode), iffix(npoin), locel(nnode)

où noeud est un tableau contenant la liste des numéros des nœuds de l’élément considéré (c’est
donc, si ielem est le numéro de l’élément, l’information contenue dans lnods(*,ielem) ).
43

La routine aura l’allure suivante


boucle de in = 1 à nnode (parcourt des nœuds de l’élément)
ipoin = noeud(in) (n° du in-ième nœud de l’élément)
nginc = iffix(ipoin) (n° global d’inconnue du d.d.l)
locel(in) = nginc (stockage de ce n° dans locel)
fin_boucle_i

Remarquez que si dans notre problème type il n’y a aucune condition aux limites de type Dirichlet
(pas de d.d.l. fixés), la table locel est bien entendu superflue puisqu’elle ne contiendra rien d’autre
que les numéros des nœuds de l’élément (dans la routine : locel = noeud).

! hauteurs des colonnes et adresses des termes diagonaux

Reprenons l’exemple du §B.5.1 :

" ! 0 ! 0 ! ! %
$ '
$ 0 ! 0 ! ! ! '

$
$ ! 0 ! 0 ! ! '
A=$ '
$ 0 ! 0 ! ! ! '
$ ! ! ! ! ! ! '
$ ! ! ! ! ! ! '
# &

Les hauteurs des colonnes sont h1 = 0, h2 = 0, h3 = 2, h4 = 2, h5 = 4, h6 = 5.


Graphiquement, elles correspondent à la plus grande différence entre un numéro de d.d.l. et ses
numéros voisins. Par exemple, le d.d.l. 6 a pour voisins les d.d.l. 1, 2, 3, 4 et 5, donc h6 = 6 ! 1 = 5.
On peut donc écrire : hi = i ! min j "Vi { j} où Vi désigne l’ensemble des d.d.l. voisins du d.d.l i.
Comme on travaille à partir de table de connectivité élémentaire donnant la liste des nœuds de
chaque élément, et non à partir de table de voisinages, on calculera hi par :
hi = max(i ! min jke )
e k

où ( jke )k=1,..,nnode désignent l’ensemble des d.d.l. attachés à l’élément e (e = 1,..., nelem).
Ainsi, pour le d.d.l. 6 on a :
! sur l’élément 1 : ( jk1 )k=1,..,nnode = (1, 6, 5, 3) ! m1 := min jk1 = 1,
k

! sur l’élément 2 : ( jk2 )k=1,..,nnode = (6, 2, 4, 5) ! m := min jk2 = 2,


2
k
e
d’où, h6 = max(6 ! m ) = 6 ! 1 = 5.
e=1,2
Les positions, pi, des termes diagonaux dans le tableau Acol sont simplement définies par les
hauteurs hi des colonnes :
"$ p1 = 1,
#
$% pi = pi!1 + hi + 1 i = 2,...,nequa.
La taille du tableau Acol est alors nesky = pnequa .
Remarque : on voit que la mémorisation des hauteurs hi n’est plus nécessaire une fois construit les pi ; on utilisera donc qu’un
seul tableau (idiag)

Structure de la routine :
! Arguments d’entrée :
La table de connectivité (lnods),
la liste des numéros d’inconnue des d.d.l. (iffix),
le nombre d’éléments dans le maillage (nelem),
le nombre de nœuds dans le maillage (npoin),
le nombre d’inconnues (nequa),
le nombre de nœuds par élément (nnode).
! Arguments de sortie :
Les nequa adresses des termes diagonaux (idiag),
l’espace nécessaire au stockage (nesky).
! Tableau de travail :
La table de localisation élémentaire (locel).
44

Synopsis :
htcol (lnods,iffix,idiag,locel,
+ nelem,npoin,nequa,nesky,
+ nnode)

lnods(nnode,nelem), iffix(npoin), idiag(nequa), locel(nnode)

Les opérations nécessaires sont les suivantes :

1) calcul des hauteurs des colonnes


(sauvegardées momentanément dans idiag):

initialiser idiag à zéro


boucle de e = 1 à nelem
appel à locelem pour extraire la table de localisation locel
calculer le plus petit n° d’inconnue > 0 de l’élément e :
min_e = min{locel(i),locel(i)>0}
boucle de iddl = 1 à nnode
iequa = locel(iddl)
si (iequa > 0) alors
calculer la différence diff = iequa - min_e
si diff>idiag(iequa) : sauvegarder diff dans idiag(iequa)
fin_si
fin_boucle_iddl
fin_boucle_e

2) mémorisation des adresses des termes diagonaux

idiag(1) = 1
boucle de i = 2 à nequa
idiag(i) = idiag(i) + idiag(i-1) + 1
fin_boucle_i
nesky = idiag(nequa)

B.5.5 Tests à réaliser

Pour le stockage par ligne de ciel : tests C.4.1 et C.4.2.


Pour la factorisation LDU et la résolution : test C.5.1.
45

B.6 La procédure d’assemblage

On rappelle qu’après discrétisation par éléments finis d’une formulation variationnelle (§A.3), on
obtient les relations
nelem ! !
" {
TeT ! keTe # fe } = 0, pour tous les Te admissibles,
e=1

où Te désigne le vecteur formé des d.d.l. associés aux nœuds de l’élément e (Te !! nnode ).
Cette somme est équivalente à la forme dite globale :
! !
T T ! (K T " F ) = 0, !T admissible,

où T est le vecteur contenant tous les d.d.l. associés aux nœuds du maillage (T !! nequa ).
Ce passage à la forme globale constitue la procédure d’assemblage et permet de résoudre le problème
sous la forme K T = F. Cette procédure a donc pour objet la construction de la matrice globale K et le
vecteur global F des sollicitations.

Pour illustrer cette procédure d’assemblage, considérons l’exemple de deux éléments à quatre nœuds :

lnods(*,1) = (1, 6, 5, 3)
lnods(*,2) = (6, 2, 4, 5)

! ! ! ! ! ! !
(T ,T ,T ,T ,T ,T )
T
Désignons par T le vecteur inconnu 1 2 3 4 5 6 et par T le vecteur (T1 , T2 , T3 , T4 , T5 , T6 )T et
! 4 ! ! 4 !
écrivons pour chaque élément e les termes TeT ! keTe = " i=1 Tei " j =1 keijTej et TeT ! fe = " i=1 Tei fei sous
4

!
forme étendue, c’est-à-dire en utilisant les vecteurs T et T :

( )
T !
! Élément 1 : T1 = T11 ,T12 ,T13 ,T14 = (T1 ,T6 ,T5 ,T3 )T et de même pour T1 ,

" k111 0 k114 0 k113 k112 %' ( T1 + " f1%


$ 1
* - $ '
$ 0 0 0 0 0 0 ' * T2 - 0
$ '
! ! $ k141 0 k144 0 k143
'
k142 ' * T3 - !T ! T $ f14 '
T1T ! k1 T1 = T T ! $ * -, T1 ! f1 = T ! $ ' .
$ 0 0 0 0 0 0 ' * T4 - $0'
$ ' $ 3'
$ k131 0 k134 0 k133 k132 ' * T5 - $ f1 '
$ '* - $ 2'
$# k121 0 k124 0 k123 k122 '& ) T6 , # f1 &

( )
T !
! Élément 2 : T2 = T21 ,T22 ,T23 ,T24 = (T6 ,T2 ,T4 ,T5 )T et de même pour T2 ,

" 0 0 0 0 0 0 % ( T1 + "0%
$ ' $ 2'
$ 0 k222 0 k223 k224 k221 ' * T2 - $ f2 '
! T $$ '* - !T $ 0 '
!T 0 0 0 0 0 0 ' * T3 - !T
T2 ! k2 T2 = T ! * -, T2 ! f2 = T ! $ 3 ' .
$ 0 k232 0 k233 k234 k231 ' * T4 - $ f2 '
$ ' $ 4'
$ 0 k242 0 k243 k244 k241 ' * T5 - $ f2 '
$ '* - $ 1'
$# 0 k212 0 k213 k214 k211 '& ) T6 , # f2 &
46

2 ! 2 !
La relation ! e=1 TeT .ke Te = ! e=1 TeT . fe donne alors

" k111 0 k114 0 k113 k112 % ( f1 +


$ ' ( T1 + *
1
-
$ 0 k222 0 k223 k224 k221 '* - * f2 -
2
$ ' * T2 - * -
!T $ k141 0 k144 0 k143 k142 ' * T3 - ! T f14 -
T !$ '* - = T !* .
$ 0 k232 0 k233 k234 k231 ' * T4 - * f3 -
2
$ ' *T - * -
$ k131 k242 k134 k243 k133 + k244 k132 + k241 '* 5- * f13 + f24 -
$ ' ) T6 , * 2 -
k121 k212 k124 k213 k123 + k214 k122 + k211 ) f1 + f21 ,
# &

L’assemblage des matrices et vecteurs élémentaires consiste donc à faire la somme de leur matrices et
de leur vecteurs étendus. En pratique, pour des raisons évidentes, on ne forme jamais les matrices
étendues. On procède au remplissage de la matrice globale K, élément par élément, en utilisant la
correspondance entre les numéros locaux des d.d.l. et les numéros globaux d’inconnues (table de
localisation élémentaire, voir §B.5.4.1) :

! les numéros locaux des d.d.l. sont ici (1, 2, 3, 4),


! ils correspondent, pour l’élément 1 à (1, 6, 5, 3), pour l’élément 2 à (6, 2, 4, 5).
De manière générale, pour un problème à inconnue scalaire (un seul degré de liberté par noeud), la
numérotation locale est i = 1, 2, ..., nnode (ici nnode = 4) et, pour un élément e, les numéros
d’inconnue correspondants sont donnés par une correspondance le (i) (c’est la table locel).
Alors, le terme (i,j) de la matrice ke se retrouve sommé dans la matrice globale K en (le (i),le ( j)) et le
terme i du vecteur élémentaire fe est sommé dans le vecteur global F en le (i) :

K le (i),le ( j) ! K le (i),le ( j) + kei, j , F le (i) ! F le (i) + fei , {


i, j ! 1,..,nnode . }

B.6.1 Organisation de l’assemblage des vecteurs élémentaires

On développera une routine d’assemblage de vecteurs élémentaires qui consistera à sommer un vecteur
élémentaire fe dans un vecteur global F.
On suppose construite la table locel de localisation élémentaire de l’élément considéré (voir la routine
locelem discutée au §B.5.4.1) qui réalise la correspondance entre les numérotations locale et globale )
des inconnues (se rappeler que, par convention, un d.d.l. fixé et en correspondance avec la valeur 0).

Structure de la routine :
! Arguments d’entrée (pour un élément e donné) :
Le vecteur élémentaire fe,
le vecteur global F,
la table de localisation élémentaire,
le nombre d’inconnues (taille du vecteur F),
le nombre de d.d.l. par élément (nnode).
! Argument de sortie :
Le vecteur global F actualisé.

Synopsis :
assembV (Fglob,Flocl,locel,nequa,nnode)
Fglob(nequa), Flocl(nnode), locel(nnode)

La routine est très simple et se présente ainsi :


boucle de iddl = 1 à nnode
inc = locel(iddl)
si inc > 0 : sommer Flocl(iddl) dans Fglob(inc)
fin_boucle_iddl
47

B.6.2 Organisation de l’assemblage des matrices élémentaires (stockage ligne de ciel)

La routine d’assemblage des matrices est légèrement plus complexe que l’assemblage des vecteurs du
fait du stockage par ligne de ciel.
On rappelle (§B.5.2) que la position, m, dans la matrice stockée par ligne de ciel, du terme Kij (j " i)
intérieur à la ligne de ciel est donnée par
m = idiag(j) ! (j!i),

i et j sont des numéros globaux (i, j = 1, ..., nequa).

La routine de sommation d’une matrice élémentaire dans la matrice globale stockée par ligne de ciel
aura la structure suivante

Structure de la routine :
! Arguments d’entrée (pour un élément e donné) :
La matrice élémentaire ke à assembler,
la matrice globale K sous forme ligne de ciel,
la table idiag des adresses des termes diagonaux,
la table locel de localisation élémentaire,
le nombre de d.d.l. par élément (nnode),
le nombre d’inconnues (nequa),
la taille de la matrice ligne de ciel (nesky).
! Argument de sortie :
La matrice globale K actualisée.

Synopsis :
assembM (Aglob,Alocl,idiag,locel,nnode,nequa,nesky)

Aglob(nesky), Alocl(nnode,nnode), idiag(nequa), locel(nnode)

Les opérations nécessaires sont les suivantes

boucle de jddl = 1 à nnode


j = locel(jddl) (j : numéro global associé à jddl)
si (j = 0) passer au suivant (le d.d.l est imposé, passer au n° jddl. suivant)
m0 = idiag(j) - j
boucle de iddl = 1 à nnode
i = locel(iddl) (i : numéro global associé à iddl)
si (i = 0) passer au suivant (le d.d.l est imposé, passer au n° iddl suivant)
si (i > 0) passer au suivant (on ne stocke que le triangle supérieur,
passer au n° iddl suivant si i > j)
m = m0 + i (m : position du terme Kij dans Aglob)
Aglob(m) = Aglob(m) + Alocl(iddl,jddl)
fin_boucle_iddl
fin_boucle_jddl

Si besoin est, on adaptera très facilement cette routine au cas des matrices non symétriques (cela
nécessitera un deuxième tableau de même longueur ! nesky ! et contenant les lignes du triangle
inférieur de la matrice).

B.6.3 Tests à réaliser

Test C.6.1 : on se donne des vecteurs et matrices élémentaires sur deux éléments et on teste
l’assemblage.
48
49

B.7 Organisation générale du calcul du vecteur et de la matrice du système

On a vu (voir remarque finale du §A.4) que les matrices et vecteurs élémentaires d’un problème
discrétisé par éléments finis pouvaient se mettre sous la forme générale :

ke = " Be (x)T D(x) Be (x) dV et fe = " N e (x)T f (x) dV + " N e (x)T Fs (x) dS.
!e !e #!e $% &

Pour calculer ces intégrales, qui peuvent contenir des termes complexes, on utilise en général une
intégration numérique. Comme on l’a vu au §B.4, on se ramène, par changement de variables, à une
intégration sur l’élément de référence sur lequel un certain nombre de choses peuvent être pré-
calculées (positions des points d’intégration, valeurs des fonctions de forme en ces points,..). Le calcul
approché de ke par exemple prend alors la forme suivante :
nipts
ke = " Be (#)T D(#) Be (#) det J(#) dV $ & % k Be (# k )T D(# k ) Be (# k ) det J(# k ).
!r k=1

Pour la partie volumique de fe on emploiera le même schéma d’intégration ; quant à sa partie


surfacique, on utilisera un schéma adéquat sur les faces des éléments concernés (dans un premier
temps, on pourra ne traiter que le cas de charges Fe uniformément réparties ou le cas des charges
ponctuelles, l’intégrale se calculant alors analytiquement).
La procédure de construction de la matrice globale K et du second membre global F a alors la structure
générale schématisée ci-dessous :

L’ensemble de ces instructions formera une routine dont on va décrire les étapes non encore étudiées en
se limitant au cas simple du problème thermique.
50

B.7.1 Calcul d’une matrice et d’un vecteur élémentaires

On décrit ici les calculs et instructions relatifs au bloc 4 du schéma précédent. On se limite au cas du
problème thermique pour lequel on a (voir §A3) les expressions suivantes des composantes de ke et fe :

% ! x Ni " "
T
e
(ke )ij = " #! x N je dV et ( fe )i = N ie r dV + N ie qn dS.
$e !e #!e $% q

On supposera pour simplifier un peu que le tenseur de conductivité ! est isotrope sur l’élément (! = kI )
et que la partie surfacique de fe a déjà été calculée et assemblée dans le vecteur global F (ou, ce qui
revient au même pour l’instant, de supposer que qn est nul).
Supposons donc que nous en sommes à traiter l’élément numéro « e » du maillage. À cette étape du
calcul, les nnode fonctions d’interpolation N ie de l’élément, leurs ndime ! nnode dérivées cartésiennes
! x N ie et le jacobien J de la transformation « élément de référence " élément réel » sont connus aux nipts
points d’intégration dont les coordonnées ! k et les poids associés ! k ont été sélectionnés une fois pour
toutes.
Les intégrales étant calculées et approchées par (voir §B.4)

nipts
(ke )ij = $ k ! x N ieT " ! x N je J % ' & k k((k ) ! x Nie ((k )T " ! x N je ((k ) J((k ),
#r k=1

nipts
( fevol )i = " N ie r J # & $ kr(% k ) Nie (% k ) J(% k ),
!r k=1

la procédure correspondante est très simple (on suppose k et r constants sur l’élément sans que cela soit
vraiment nécessaire) :

# Arguments d’entrée :
Les ndime ! nnode dérivées cartésiennes ! x N ie estimées aux nipts points d’intégration,
les nnode fonctions d’interpolation N ie estimées aux nipts points d’intégration,
le jacobien J du changement de variable évalué aux nipts points d’intégration,
les nipts poids ! k associés aux points d’intégration,
les propriétés thermiques k et r de l’élément,
la dimension ndime de l’espace,
le nombre nnode de nœuds dans l’élément,
le nombre nipts de points d’intégration.

# Arguments de sortie :
La matrice de rigidité élémentaire ke,
le vecteur élémentaire fe.

Synopsis :
rigidel (Alocl,Flocl,dcart,shape,
+ djacb,poids,condu,sourc,
+ ndime,nnode,nipts)

Alocl( nnode,nnode), Flocl( nnode)


dcart(ndime,nnode,nipts), shape(nnode,nipts)
djacb( nipts), poids( nipts)

Alocl : matrice de rigidité élémentaire ke
Flocl : vecteur élémentaire fe
dcart : tableaux contenant les valeurs des dérivées cartésiennes aux points d’intégration
shape : tableaux contenant les valeurs des fonctions de forme aux points d’intégration
djacb : tableaux contenant les valeurs du jacobien aux points d’intégration
poids : tableaux contenant les valeurs des poids de la quadrature
condu : conductivité thermique (k)
sourc : apport volumique de chaleur (r)
51

Les instructions sont les suivantes :


boucle de k = 1 à nipts
delta = poids(k)*djacb(k)
boucle de i = 1 à nnode
1) calcul des termes k ! k J(" k ) # x N ie (" k )T $ # x N je (" k ) (pour j $ i)
et sommation dans ke :
boucle de j = i à nnode
calculer le produit scalaire ps = ! x N iTe " ! x N je
Alocl(i,j) = Alocl(i,j) + delta * condu * ps
fin_boucle_j
2) calcul des termes r ! k N ie ("k ) J("k ) et sommation dans fe :
Flocl(i) = Flocl(i) + delta * sourc * shape(i,k)
fin_boucle_i
fin_boucle_k
3) compléter, par symétrie, le triangle inférieur de ke

B.7.2 La prise en compte des conditions aux limites de type Dirichlet

La prise en compte des valeurs imposées du champ inconnu T peut se faire de différentes manières (voir
Dhatt et Touzot). La méthode que l’on décrit ici consiste à ne garder dans le système final K T = F que
les composantes Ti de T qui ne sont pas données. Pour cela, il faut restructurer la matrice K et le second
membre F en éliminant les équations inutiles (méthode de suppression des équations). Supposons que la
k-ième composante de T soit donnée :

Tk = Tk .
Écrivons T sous la forme :
T = T! + T ,
avec
T = (0,...,0,Tk ,0,..,0)T et T! = (T1 ,...,Tk!1 ,0,Tk+1 ,...,Tn )T .
Alors,
K T! = F ! KT =: F! ,
c’est-à-dire,
" KijTj = fi # KikTk , i = 1, ..., n.
j!k

On peut donc extraire un sous système,


K ' T ' = F ',

correspondant aux n"1 inconnues T1 ,...,Tk!1 ,Tk+1 ,...,Tn en supprimant la k-ième ligne et la k-ième
colonne de K et qui a pour second membre le vecteur de composantes :
fi' = fi ! K ikTk .

L’ensemble de ces opérations peut se faire au niveau élémentaire, c’est à dire avant assemblage, ce qui,
évidemment, est plus avantageux que de le faire au niveau global. On se situe donc, à ce stade, dans la
boucle sur les éléments, après le calcul de ke et fe et avant l’assemblage (bloc 5 du schéma).

Remarquer que la procédure d’assemblage de matrice décrite au §B.6.2 n’assemble pas les équations
inutiles. On a donc déjà la matrice K ' à l’issue de cette procédure et il ne reste donc plus qu’à modifier
le second membre élémentaire fe avant assemblage de celui-ci dans F.

La procédure consiste donc à :


• former le vecteur Te dont les composantes sont soit 0 (d.d.l. libre) soit une valeur imposée,
• calculer le vecteur keTe et le retrancher à fe.
52

La structure de la routine correspondante se présente alors comme suit :


Dirichlet (Flocl,Tbare,Tfixe,Alocl,
+ noeud,locel,nnode,npoin)

Flocl( nnode), Tbare(nnode), Tfixe(npoin)


Alocl(nnode,nnode), noeud(nnode), locel(nnode)

Construction de Te :
boucle de in = 1 à nnode (on parcourt les noeuds de l’élément)
nddl = locel(in) (numéro global du d.d.l. associé à ce noeud)
si (nddl = 0) alors (s’il est imposé :
ipoin = noeud(in) numéro global du noeud
Tbare(in) = Tfixe(ipoin) mettre la valeur imposée dans Tbare)
sinon (s’il est libre :
Tbare(in) = 0.0 mettre 0 dans Tbare)
fin_si
fin_boucle_in

Calcul de fe ! fe " keTe

Suggestion : on peut mettre un test pour éviter d’avoir à faire le produit keTe si aucun des d.d.l. de
l’élément n’est imposé.
Remarque : par souci de simplicité on a décidé de mettre les valeurs fixées de T dans un tableau Tfixe de dimension npoin, ce qui
n’est évidemment pas optimal d’un point de vue de l’occupation mémoire (voir §B.2.2.4) !

B.7.3 Organisation générale

On est maintenant en mesure de rassembler tous les morceaux développés durant les différents
paragraphes afin de former le « noyau » de notre code, à savoir, le calcul de la matrice globale K et le
vecteur second membre F. On peut le présenter sous la forme d’une routine qui sera directement
appelée par le programme principal.

matrix (Aglob,Fglob,coord,lnods,
+ props,idiag,Tfixe,iffix,
Tableaux globaux
+ matno,

+ Alocl,Flocl,cdnod,Tbare,
Tableaux élémentaires
+ shape,deriv,dcart,djacb,
+ cdpti,poids,noeud,locel,

+ nesky,ndime,npoin,nnode, Variables de dimensionnement


+ nelem,nmats,nequa,nipts)

Aglob( nesky), Fglob( nequa)


coord( ndime,npoin), lnods( nnode,nelem)
props( 2,nmats), idiag( nequa)
Tfixe( npoin), iffix( npoin)
matno( nelem)
Alocl( nnode,nnode), Flocl( nnode)
cdnod( ndime,nnode), Tbare( nnode)
shape( nnode,nipts), deriv(ndime,nnode,nipts)
dcart(ndime,nnode,nipts), djacb( nipts)
cdpti( ndime,nipts), poids( nipts)
noeud( nnode), locel( nnode)

Les différentes étapes de cette routine sont reprises ci-dessous (voir aussi le schéma en début de ce
paragraphe). Elles représentent de simples appels à des routines que nous avons, pour la plupart, déjà
détaillées. Pour chacune d’elles on rappelle le numéro du paragraphe la détaillant.
53

1. Calcul des coordonnées des points d’intégration et des poids associés


(sauvegarde dans des tableaux cdpti(ndime,nipts) et poids(nipts))
" appel à Ggauss (cdpti,poids,...) (voir §B.4.6)

2. Calcul, sur l’élément de référence, des fonctions de forme et de leurs dérivées aux points
d’intégration
(sauvegarde dans des tableaux shape(nnode,nipts) et deriv(ndime,nnode,nipts))
boucle ig = 1 à nipts
appel à Gshape (shape(1,ig),deriv(1,1,ig),...) (voir §B.3.7.1)
fin_boucle_ig
3. Calcul de la matrice de rigidité et du second membre :

boucle e = 1, nelem

3.1 Initialisation à zéro de la matrice de rigidité élémentaire et du second membre élémentaire

3.2 Extraction des coordonnées et des numéros des noeuds de l’élément


(sauvegarde dans un tableau cdnod(ndime,nnode) et noeud(nnode)
La faire au moyen d’une routine lcoord :
" appel à lcoord (cdnod,noeud,...)

3.3 Extraction de la table de localisation élémentaire


(sauvegarde dans un tableau locel(nnode))
" appel à locelem (locel,...) (voir §B.5.4.1)

3.4 Numéro de matériau auquel appartient l’élément e : (voir §B.2.2.4)


imat = matno(e)
et propriétés thermiques correspondantes (k et r) : (voir §B.2.2.4)
condu = props(1,imat) sourc = props(2,imat)

3.5 Calcul du jacobien et des dérivées cartésiennes


(sauvegarde dans des tableaux djacb(nipts) et dcart(ndime,nnode,nipts)
boucle ig = 1, nipts
" appel à jacob (djacb(ig),dcart(1,1,ig),...) (voir §B.3.7.2)
fin_boucle_ig

3.6 Calcul de la matrice de rigidité élémentaire et du second membre élémentaire


(sauvegarde dans un tableau Alocl(nnode,nnode) et Flocl(nnode))
" appel à rigidel(Alocl,Flocl,...) (voir le §B.7.2)

3.7 Modification du second membre par imposition des conditions aux limites de Dirichlet
(modification de Flocl(nnode))
" appel à Dirichlet(Flocl,...) (voir le §B.7.3)

3.8 Assemblage de la matrice de rigidité élémentaire (Alocl) dans la matrice globale (Aglob)
" appel à assembM (Aglob,Alocl,...) (voir §B.6.2)

3.9 Assemblage du vecteur élémentaire (Flocl) dans le vecteur global (Fglob)


" appel à assembV (Fglob,Flocl,...) (voir §B.6.1)

fin_boucle_e
54

B.7.4 Remarques sur le calcul des charges

B.7.4.1 Organisation du calcul des charges surfaciques par faces élémentaires

Si l’on connaît l’ensemble des faces élémentaires ! qe = "#e $ ! q % & se trouvant sur la frontière ! q où
s’applique la charge qn, il est plus intéressant de calculer les charges surfaciques

( fe )i = " Ni (x) qn (x) dS


! qe
en parcourant ces diverses faces que de le faire en parcourant tous les éléments et en ne retenant que
ceux ayant une face sur la frontière ! q (tel que cela est présenté dans le schéma général). En effet,
l’utilisation d’éléments conformes, fait que sur un élément !e donné, les fonctions de forme des nœuds
qui ne se trouvent pas sur la face ! qe sont nulles. Il s’ensuit que la connaissance de la liste des nœuds
formant ! qe est suffisante.

Par exemple, avec l’élément triangulaire à 6 nœuds ci-contre, on a :


fe = ( f1e , f2e , f3e , f4e , f5e , f6e )T
et si ! qe est formée des nœuds 1, 4 et 2 on aura à calculer uniquement :
f1e = " N1 (x)qn (x) dS, f4e = " N 4 (x)qn (x) dS et f2e = " N 2 (x)qn (x) dS
! qe ! qe ! qe

puisque N 3 = N 5 = N 6 ! 0 sur ! qe .

Le calcul de ces intégrales est mené de la même manière que celui des intégrales sur l’élément : on
utilise un changement de variables transformant la face élémentaire ! qe en un élément de référence
correspondant (de dimension ndime"1). Si on n’utilise que des éléments à côtés droits (resp. à faces
planes), on se contente d’une transformation géométrique linéaire. À titre d’exemple, considérons le cas
d’un triangle dont le côté 1-2 forme la face ! qe :

et supposons que l’on veuille calculer l’intégrale

" f (x, y) dl ( dl = dx 2 + dy 2 ).
! qe

La transformation géométrique # est définie par :

! : " #[$1, 1] ! x = (x, y) #% qe

Comme dx = (dx d! )d! , dy = (dy d! )d! , l’élément différentiel dl s’écrit : dl = J(! ) d! où le jacobien de

la transformation est J(! ) = x '(! )2 + y '(! )2 .

L’intégrale s’exprime donc par


1

" f (x, y) dl = " f ! #($) J($) d$.


! qe %1

2
Si l’on choisit une transformation # linéaire on a ! (" ) = # i=1 N i (" )xi où les deux fonctions N i sont les
fonctions de forme de l’élément linéaire 1D à 2 nœuds : N1 (! ) = (1 " ! ) 2 , N 2 (! ) = (1 + ! ) 2.
55

On a donc dans ce cas J(! ) = J = 1


(x2 " x1 )2 + (y2 " y1 )2 = 1 L, L étant la longueur du côté ! qe .
2 2
Finalement,
1
L
" f (x, y) dl = " f ! #($) d$,
2 %1
! qe
et cette dernière intégrale peut être calculée par intégration numérique.

Ce résultat est aussi valable pour d’autres formes d’éléments (Q4, T6, Q9,...), la seule condition est que
le côté ! qe soit rectiligne (élément à côtés droits). Si ce n’est pas le cas, il faut utiliser une
approximation géométrique # non linéaire compatible avec la courbure de l’élément.

Pour résumer, l’expression


fie = " q
N i (x)qn (x) dS, pour tout nœud i sur ! qe rectiligne
! e

se calcule par
1
L
fi = # N i (! )qn (! ) d! avec L = mes(! qe ).
e
2 "1

B.7.4.2 Le cas des charges surfaciques constantes par morceaux ou ponctuelles (cas 2D)

On reprend le résultat précédent relatif aux éléments à côtés droits et on examine deux cas particuliers
de forces surfaciques dont l’utilisation est assez courante. On donne les formules d’intégration exacte
pour les éléments ayant deux ou trois nœuds par côté.

a) « Charge » constante sur ! qe


1
Lqn
Le calcul de fie = " N i (x)qn (x) dS se réduit à fie =
2 $ N i (! (" )) d".
! qe #1

# Élément à deux nœuds sur ! qe (élément T3 ou Q4) :


La restriction à ! qe des fonctions de forme attachées aux 2 nœuds est N i (! (" )) = 1 (1 ± " ) . On a
2
donc :
L
fie = qn .
2
(la « charge » totale Lqn est distribuée également entre les deux nœuds) .

# Élément à trois nœuds sur ! qe (élément T6 ou Q8) :


La restriction à ! qe des fonctions de forme attachées aux 3 nœuds est
• aux deux extrémités : 1
(! 2 ± ! ),
2

• au nœud milieu : 1 ! " 2 .

Les « charges » nodales équivalentes sont donc :


L
• aux extrémités de ! qe : qn ,
6
4L
• au nœud milieu : qn .
6
Remarquer que la « charge » totale Lqn est toujours conservée.
56

L’organisation de ces calculs est la suivante :


q
boucle de e = 1 à nfacN (boucle sur les différentes faces ! e du maillage)
calculer la longueur dL de la face
boucle de n = 1 à noeuf (boucle sur les nœuds de la face (noeuf = 2 ou 3))
ipoin = lfacN(n,e) (numéro global du n-ième nœud de la face e)
nddl = iffix(ipoin) (numéro global du d.d.l. correspondant)
f = cn * dL * charg(e)
Fglob(nddl) = Fglob(nddl) + f (assemblage dans sourc)
fin_boucle_n
fin_boucle_e

où cn sont les coefficients de pondération (suivant les cas : 1/2, 1/2 ou 1/6, 1/6, 2/3) et charg(e) est la
charge imposée sur la face e.

b) « Charge » ponctuelle : qn (x) = q! (x k ) , xk correspondant à un nœud du maillage.

Dans ce cas
fie = " q
N i (x)qn (x) dS = qN i (x k ) = q# ik .
! e

C’est donc le cas le plus simple à programmer : les charges sont directement attribuées aux nœuds
où elles s’appliquent.
boucle de iforc = 1 à nforc (boucle sur les « forces » concentrées)
ipoin = lforc(iforc) (numéro du nœud où s’applique la charge n° iforc)
nddl = iffix(ipoin) (numéro global du d.d.l. correspondant)
Fglob(nddl) = Fglob(nddl) + forcc(iforc)
fin_boucle_k

Noter que dans certains codes, le calcul des charges nodales fait partie du pré-traitement, elles sont
données par l’utilisateur sous forme de charges ponctuelles.

On développera une routine unique (que l’on pourra étendre, si besoin, au 3D) qui sera appelée par le
programme principal avant le calcul des matrices et vecteurs élémentaires :
solicsuf (lfacN,lforc,charg,forcc,
iffix,coord,Fglob,
nfacN,nforc,nequa,npoin,
ndime,noeuf)
lfacN(noeuf,nfacN), lforc( nforc), charg( nfacN),
forcc( nforc), iffix( npoin), coord(ndime,npoin),
Fglob( nequa)
où (voir aussi §B.2.2.4)
lfacN : donne la liste des noeuf nœuds de chaque « facettes de Neumann »,
charg : tableau où sont rangées les valeurs imposées des charges sur ces facettes élémentaires,
lforc : donne la liste des « nœuds de Neumann »,
forcc : tableau où sont rangées les valeurs imposées des charges en ces nœuds,
iffix : table donnant les n° d’inconnue associés à chaque nœud du maillage,
coord : table contenant les coordonnées des nœuds du maillage,
Fglob : vecteur second membre,
nfacN : nombre de facettes élémentaires où des conditions de Neumann sont imposées,
nforc : nombre de charges concentrées,
nequa : nombre total d’inconnues,
npoin : nombre total de nœuds dans le maillage,
ndime : dimension de l’espace,
noeuf : nombre de nœuds sur une facette élémentaire.

B.7.5 Tests à réaliser


Pour le calcul par faces élémentaires des forces nodales équivalentes : C.7.1.
Pour le calcul des vecteurs et matrices élémentaires : tests C.8.1 et C.8.2.
Pour des exemples complets : tests C.8.3, C.8.4 et C.8.5.
57

B.8 Le post-traitement : le calcul des grandeurs dérivées

B.8.1 Le calcul des flux (et des contraintes)

Une fois déterminée la solution approchée du champ primal (ici le déplacement ou la température), on
peut vouloir connaître la solution approchée du champ dual (les contraintes de Cauchy ou le flux
thermique). Ce champ s’exprime en fonction des dérivées partielles du premier. Il est donné ici par :

# q = !" gradT pour le problème thermique (q est un vecteur de !ndime ).


# ! = C " = 12 C (grad u + grad uT ) pour le problème élastique ($ est un tenseur de !ndime dans !ndime ).
Pour des raisons pratiques, on écrira la seconde relation sous la forme « vectorielle » s = S e où s et e
désignent des vecteurs contenant les composantes indépendantes de % et & respectivement (voir §A.4).
On a vu que la forme discrète des ces deux lois pouvait s’écrire sur chaque élément e :

de (x) = De Be (x) ve ,

avec de l’approximation du champ dérivé en tout point de l’élément (de = qe ou se), ve les valeurs aux
nœuds de l’élément du champ approché (ve = Te ou ue), De la matrice des propriétés physiques sur
l’élément (De ="! e ou Se) et Be une matrice contenant les dérivées partielles des fonctions de forme.
On peut donc évaluer les grandeurs dérivées d en tout point d’un élément une fois connu le champ
approché v. Mais ceci ne doit pas faire oublier que ces grandeurs ne sont pas, en général, continues d’un
élément à l’autre. En effet, on a assuré la continuité Co du champ v par l’utilisation d’éléments
conformes mais rien ne garantit la continuité de ses dérivées à la traversée des frontières inter-
éléments.
Dans la pratique, on se contente d’évaluer d en des points intérieurs à chaque élément. Par exemple, si
l’on a utilisé des points d’intégration pour calculer les matrices de rigidité élémentaires (donc calculé De
et Be en ces points), on peut réutiliser ces calculs pour évaluer d en ces points. L’organisation générale
de la procédure est alors assez semblable à celle présentée au §B.7.3. La représentation graphique de
ces valeurs nécessite alors la connaissance des coordonnées cartésiennes xm (m = 1,..., nipts % nelem)
des points d’intégration dont on connaît les coordonnées locales & k. Elles s’obtiennent facilement par la
transformation géométrique utilisée :
nnode
xm = ! N i ("k )xie , k=1,...,nipts et m = (e#1) nipts + k,
i=1

xie désignant les coordonnées des nœuds de l’élément.

Pour des besoins pratiques de visualisation, on peut aussi se contenter d’une valeur moyenne de d sur
chaque élément. Cette valeur moyenne peut être calculée en faisant une moyenne des valeurs obtenues
aux points d’intégration
nipts
1 1
de =
nipts
" de (!k ) ou de =
mes(!e ) !"
de (x) dV .
k=1 e

On peut aussi vouloir une représentation continue de d. Pour cela on réalise un lissage nodal de d. Il
existe plusieurs façons de faire, notamment,

# par extrapolation aux nœuds des valeurs moyennes :


Une manière très simple est d’utiliser les valeurs moyennes de . Pour
chaque nœud i du maillage, on réalise une moyenne des de
correspondant aux éléments entourant ce nœud. On obtient donc des
valeurs nodales di que l’on peut utiliser pour représenter d en tout
point du domaine par une approximation nodale :

d(x) = ! N i (x) di .
i
58

# par extrapolation directe des valeurs calculées aux points d’intégration :


Un peu moins simple à mettre en œuvre puisqu’il faut chercher les points d’intégration qui
entourent chaque nœud i du maillage.

# par lissage par moindres carrés :


Plus complexe à mettre en œuvre, elle consiste à trouver les di minimisant

# [d(xm ) ! # Ni ("k ) di ]2 ,
k i

où d(xm ) sont les valeurs connues aux points d’intégration.


On distingue alors les méthodes globales (plus coûteuses) où on applique cette méthode sur tout le
domaine et les méthodes locales où on l’applique par paquets d’éléments adjacents.

Pour nos besoins, on pourra se contenter de la première méthode. La procédure informatique peut être
organisée comme suit (pour une variable d scalaire):
Initialisation à zéro des di et
boucle de ipoin = 1 à npoin d’une table comptabilisant les
dnodl(ipoin) = 0 connections nodales
conec(ipoin) = 0
fin_boucle_ipoin

boucle de e = 1 à nelem
delem = 0 Calcul de la moyenne des
boucle de ipnti = 1 à nipts valeurs calculées aux
delem = delem + d(ipnti,e) points d’intégration
fin_boucle_ipnti
delem = delem / nipts

boucle de inœud = 1 à nnode Somme des valeurs


ipoin = lnods(inœud,e) moyennes et comptage du
dnodl(ipoin) = dnodl(ipoin) + delem nombre de connections
conec(ipoin) = conec(ipoin) + 1
fin_boucle_inœud
fin_boucle_e
Diviser par le nombre de
boucle de ipoin = 1 à npoin
dnodl(ipoin) = dnodl(ipoin) / conec(ipoin) connections
fin_boucle_ipoin

B.8.2 La visualisation des grandeurs tensorielles

# Les vecteurs (ex. le flux de chaleur, le déplacement,...)


Pas de difficultés particulières (sauf pour le 3D où la visualisation n’est pas pratique !). Noter qu’en
général les logiciels de visualisation demandent soit les composantes des vecteurs, soit la norme et la
direction (souvent l’angle (Ox,v) en 2D et en coordonnées cartésiennes).

# Les tenseurs du 2e ordre (ex. le tenseurs des contraintes et des déformations,...)


En 2D un tenseur t du 2e ordre symétrique est souvent représenté sous forme de deux bi-flèches
orthogonales (croix des contraintes par exemple) dont les directions indiquent les directions propres
du tenseur et les longueurs les valeurs absolues des valeurs propres. Le sens des flèches renseigne
sur le signe des valeurs propres. Par exemple, le tenseur plan de déformation :
# &
! = 10"3 % 1 2 (
$ 2 1 '
qui a pour base principale les vecteurs (1,1) et (#1,1)T et pour valeurs principales '1 = 3.10-3 et '2
T

=#10-3 se représente dans son plan par la croix :

indiquant une extension de 3% dans la direction '/4 et une contraction de 1% dans la direction #'/4.
59

Une autre forme de représentation très utilisée en mécanique est la représentation d’invariants. Les
invariants les plus utilisés sont :

1
# I1 = trace(t), quantité appelée premier invariant de t et qui correspond à la moyenne des
3
valeurs propres (pour les contraintes on parlera de pression moyenne).

# I2 = 1
2
t : t ou J 2 = 1
2
dev t : dev t, c’est-à-dire, le second invariant de t et de son déviateur
dev t. Cette dernière quantité, souvent appelée contrainte équivalente de Von Mises, est très
utilisée en mécanique car elle mesure la résistance d’un matériau et intervient directement dans
les critères de rupture et de plasticité (voir le cours sur la plasticité).
60
PARTIE C
Ensemble de tests à réaliser au cours du développement

On écrira sur le répertoire camef/tests des petits programmes qui permettront de tester les
différentes parties que l’on vient de décrire.

Suggestions : utiliser un répertoire différent pour chaque groupe de tests (ex. tests/interpol, tests/quadrature, ...) et
utiliser sur chacun d’eux un makefile pour la compilation.

C.1 L’interpolation sur un élément de référence

Routines appelées : element_xxxx et Gshape.

C.1.1 test 1 : les fonctions Ni

Faire lire les coordonnées ! d’un point sur l’élément de référence et appeler les différentes routines de
calcul de fonction de forme. Vérifier que :
• si ! correspond à un des nœuds, ! = ! k, de l’élément alors Ni(!) = !ik.
• si ! correspond au centre de l’élément, alors Ni(!) = 1/nnode pour les éléments linéaires.
• " Ni (!) = 1 et que " " i Ni (!) = !, où " i sont les coordonnées des nœuds de l’élément de référence.

C.1.2 test 2 : l’interpolation d’une fonction

Utiliser le programme précédent en y rajoutant des routines calculant les valeurs des fonctions
suivantes :
# En 1D :
f(x) = x2 + x + 1,
f(x) = cos (# x / 3).
# En 2D :
f(x,y) = x2 + y2 + xy + x + y + 1,
f(x,y) = cos (# x y / 3).

Calculer alors les valeurs fi de ces fonctions aux noeuds de l’élément de référence et au point !.
Comparer la valeur interpolée F(!) = " Ni (!) fi à la valeur vraie f(!). Vérifier les résultats suivants :

ELEMENTS 1D :

x = 0.7
a) élément linéaire (S2)

fonctions N_i et dérivées en x = 0.70000


I N_i N_i|x
1 0.15000 -0.50000
2 0.85000 0.50000

Somme (N_i) = 1.0


Somme (ksi_i * N_i) = 0.7

Interpolation d'une fonction en x = 0.70000


1) f(x) = x2 + x + 1
Somme (N_i * f_i) = 2.7
Valeur theorique = 2.19 Ecart = -23.2876712 %
62
2) f(x) = cos(pi*x/3)
Somme (N_i * f_i) = 0.499999975
Valeur theorique = 0.743144812 Ecart = 32.7183657 %

b) élément quadratique (S3)


fonctions N_i et dérivées en x = 0.70000
I N_i N_i|x
1 -0.10500 0.20000
2 0.59500 1.20000
3 0.51000 -1.40000
Somme (N_i) = 1.0
Somme (ksi_i * N_i) = 0.7

Interpolation d'une fonction en x = 0.70000


1) f(x) = x2 + x + 1
Somme (N_i * f_i) = 2.19
Valeur theorique = 2.19 Ecart = 0. %

2) f(x) = cos(pi*x/3)
Somme (N_i * f_i) = 0.754999988
Valeur theorique = 0.743144812 Ecart = -1.59527129 %

ELEMENTS 2D :

x = 0.1 y = 0.7
a) élément triangle linéaire (T3)
fonctions N_i et dérivées en x,y = 0.10000 , 0.70000
I N_i N_i|x N_i|y
1 0.20000 -1.00000 -1.00000
2 0.10000 1.00000 0.00000
3 0.70000 0.00000 1.00000
Somme (N_i) = 1.0
Somme (ksi_i * N_i) = 0.1
Somme (eta_i * N_i) = 0.7

Interpolation d'une fonction en x,y = 0.10000 , 0.70000


1) f(x,y) = x2 + y2 + x*y + x + y + 1
Somme (N_i * f_i) = 2.6
Valeur theorique = 2.37 Ecart = -9.70464135 %
2) f(x,y) = cos(pi*x*y/3)
Somme (N_i * f_i) = 1.
Valeur theorique = 0.997314477 Ecart = -0.269275438 %

b) élément triangle quadratique (T6)


fonctions N_i et dérivées en x,y = 0.10000 , 0.70000
I N_i N_i|x N_i|y
1 -0.12000 0.20000 0.20000
2 -0.08000 -0.60000 0.00000
3 0.28000 0.00000 1.80000
4 0.08000 0.40000 -0.40000
5 0.28000 2.80000 0.40000
6 0.56000 -2.80000 -2.00000
Somme (N_i) = 1.0
Somme (ksi_i * N_i) = 0.1
Somme (eta_i * N_i) = 0.7

Interpolation d'une fonction en x,y = 0.10000 , 0.70000


1) f(x,y) = x2 + y2 + x*y + x + y + 1
Somme (N_i * f_i) = 2.37
Valeur theorique = 2.37 Ecart = 1.87379413E-14 %
2) f(x,y) = cos(pi*x*y/3)
Somme (N_i * f_i) = 0.990459231
Valeur theorique = 0.997314477 Ecart = 0.687370574 %

c) élément carré bilinéaire (Q4)


fonctions N_i et dérivées en x,y = 0.10000 , 0.70000
I N_i N_i|x N_i|y
1 0.06750 -0.07500 -0.22500
2 0.08250 0.07500 -0.27500
3 0.46750 0.42500 0.27500
4 0.38250 -0.42500 0.22500
Somme (N_i) = 1.0
Somme (ksi_i * N_i) = 0.1
Somme (eta_i * N_i) = 0.7
63
Interpolation d'une fonction en x,y = 0.10000 , 0.70000
1) f(x,y) = x2 + y2 + x*y + x + y + 1
Somme (N_i * f_i) = 3.87
Valeur theorique = 2.37 Ecart = -63.2911392 %
2) f(x,y) = cos(pi*x*y/3)
Somme (N_i * f_i) = 0.499999975
Valeur theorique = 0.997314477 Ecart = 49.8653648 %

d) élément carré quadratique (Q9)

fonctions N_i et dérivées en x,y = 0.10000 , 0.70000


I N_i N_i|x N_i|y
1 0.00473 0.04200 -0.00900
2 -0.00578 -0.06300 0.01100
3 0.03272 0.35700 0.06600
4 -0.02677 -0.23800 -0.05400
5 -0.10395 0.02100 0.19800
6 0.02805 0.30600 -0.07700
7 0.58905 -0.11900 1.18800
8 -0.02295 -0.20400 0.06300
9 0.50490 -0.10200 -1.38600
Somme (N_i) = 1.
Somme (ksi_i * N_i) = 0.1
Somme (eta_i * N_i) = 0.7

Interpolation d'une fonction en x,y = 0.10000 0.70000


1) f(x,y) = x2 + y2 + x*y + x + y + 1
Somme (N_i * f_i) = 2.37
Valeur theorique = 2.37 Ecart = 1.87379413E-14 %
2) f(x,y) = cos(pi*x*y/3)
Somme (N_i * f_i) = 0.99755
Valeur theorique = 0.997314477 Ecart = -0.0236157006 %

C.2 Le calcul des dérivées cartésiennes


Routines appelées : element_xxxx, jacob, Gshape.

Écrire un programme lisant les coordonnées (quelconques) des nœuds d’un élément (pour chaque type
d’élément) et d’un point ! arbitraire de son élément de référence. Faire appeler pour chacun d’eux la
routine de calcul des fonctions de forme et de leurs dérivées locales (element_xxxx) puis calculer le
jacobien et les dérivées cartésiennes (jacob):

C.2.1 test 1
Vérifier que si l’élément réel est identique à l’élément de référence, alors detJ = 1 et $ xNi = $ " Ni , %x.

C.2.2 test 2
Vérifier les résultats particuliers suivants

# sur le quadrangle bilinéaire de sommets (0 ;0), (0.7 ;-0.1), (2 ;1.5), (0.2 ;1) :
En ! (0 ; 0) :

detJ = 0.368749998

i d(N_i)/dx d(N_i)/dy
1 -0.372881359 -0.169491521
2 0.50847458 -0.677966106
3 0.372881359 0.169491521
4 -0.50847458 0.677966106

En ! (0.4 ; -0.7) :

detJ = 0.309499997
i d(N_i)/dx d(N_i)/dy
1 -0.977382887 0.456381274
2 0.969305341 -1.15508887
3 0.17770598 0.37156704
4 -0.169628435 0.327140551
64

# sur le triangle linéaire de sommets (0 ;0), (2 ;-0.3), (0.8 ;1) :


Quel que soit ! :
detJ = 2.24000001
i d(N_i)/dx d(N_i)/dy
1 -0.580357145 -0.535714277
2 0.446428569 -0.35714286
3 0.133928576 0.892857138

# sur le triangle quadratique de sommets (0 ;0), (2 ;-0.3), (0.8 ;1), les autres noeuds étant au milieu
de chaque côté :

Quel que soit !, detJ = 2.24000001 (car triangle à côtés droits)

En ! (0 ; 0) :
i d(N_i)/dx d(N_i)/dy
1 -1.74107143 -1.60714283
2 -0.446428569 0.35714286
3 -0.133928576 -0.892857138
4 1.78571428 -1.42857144
5 0. 0.
6 0.535714304 3.57142855

En ! (0.1 ; 0.7) :
i d(N_i)/dx d(N_i)/dy
1 0.116071429 0.107142855
2 -0.267857141 0.214285716
3 0.241071437 1.60714285
4 0.124999997 -0.499999999
5 1.30357142 -0.642857154
6 -1.51785714 -0.785714266

C.3 L’intégration numérique

Routines appelées : gauss_xxxx et Ggauss.


On vérifie les routines d’intégration numérique et la qualité des schémas d’intégration en intégrant des
polynômes de degrés de plus en plus élevés.
On écrira un programme calculant des coefficients ai aléatoires et comparant la valeur théorique de
l’intégrale à la valeur numérique obtenue pour différents nombres de points d’intégration. On vérifiera,
pour l’intégration sur le segment et sur le carré, que la solution est exacte si le nombre de points
d’intégration nipts est tel que
2 nipts #1 & degré du polynôme.
Faire de même avec des fonctions non polynomiales.

Exemple 1 : intégration sur le segment [-1,1] :


** Intégration d'un polynôme de degré 3 ** ** Intégration de exp(0.4356*x) **

ao = 0.680375457, a1 = -0.211234152, Résultat théorique : 0.20639E+01


a2 = 0.566198468, a3 = 0.596880078
quadrature à : 1 point d'intégration
Résultat théorique : 1.73822 Résultat : 0.20000E+01
Erreur : 0.63852E-01
quadrature à : 1 point d'intégration
Résultat : 1.36075 quadrature à : 2 points d'intégration
Erreur relative : 21.71569 % Résultat : 0.20636E+01
Erreur : 0.26871E-03
quadrature à : 2 points d'intégration
Résultat : 1.73822 quadrature à : 3 points d'intégration
Erreur relative : 0.00000 % Résultat : 0.20639E+01
Erreur : 0.43628E-06
quadrature à : 3 points d'intégration
Résultat : 1.73822 quadrature à : 4 points d'intégration
Erreur relative : 0.00000 % Résultat : 0.20639E+01
Erreur : 0.37501E-09
quadrature à : 4 points d'intégration
Résultat : 1.73822
Erreur relative : 0.00000 %
65

{
Exemple 2 : intégration sur le triangle (x, y) / 0 ! x ! 1;0 ! y ! 1 " x }
** intégration d’un polynôme de degré 3 ** ** intégration de sin(a*x) * cos(b*y) **

P=1 + x + y + x2 + xy + y2 + x3 + x2y + xy2 + y3 avec a = ' et b = ' / 2

Résultat théorique :1.175 (47/40) Résultat théorique :0.270189808 (8/3'2)


quadrature à : 1 point d'intégration quadrature à : 1 point d'intégration
Résultat : 1.074074074 Résultat : 0.375000003
Erreur relative : 8.589436795 % Erreur relative : 38.791320782 %
quadrature à : 3 points d'intégration quadrature à : 3 points d'intégration
Résultat : 1.166666667 Résultat : 0.284517794
Erreur relative : 0.709215829 % Erreur relative : 5.302933662 %
quadrature à : 7 points d'intégration quadrature à : 7 points d'intégration
Résultat : 1.175000023 Résultat : 0.270423040
Erreur relative : 0.000005996 % Erreur relative : 0.086321530 %

C.4 Le stockage par ligne de ciel


Routines appelées : locelem et htcol.

On teste la procédure de stockage (calcul des hauteurs et de la table idiag) sur l’exemple vu dans le
cours :

Pour cela, écrire un programme initialisant la table de connectivité lnods et la table des numéros
d’inconnues iffix. Vérifier les résultats suivants où l’on a pris :

lnods(*,1) : (1 6 5 3)
lnods(*,2) : (6 2 4 5)

C.4.1 test 1 : un seul d.d.l. par noeud (ex. : thermique)

a) aucun d.d.l. imposé : nequa = 6


iffix : (1 2 3 4 5 6)
nesky = 19
idiag : (1 2 5 8 13 19)

b) le d.d.l. associé au noeud 4 est imposé : nequa = 5


iffix : (1 2 3 0 4 5)
nesky = 14
idiag : (1 2 5 9 14)

C.4.2 test 2 : renumérotation

On prend la numérotation optimale des noeuds :


lnods(*,1) : (1 3 4 2)
lnods(*,2) : (3 5 6 4)

Aucun fixé : nequa = 6


iffix : (1 2 3 4 5 6)
nesky = 17
idiag : (1 3 6 10 13 17)
66

C.5 La décomposition LDU et la résolution

Routines appelées : decLDU, solLDU.

C.5.1 test 1 :

On se donne la matrice rangée par ligne de ciel suivante :

A : (1 0 1 -1 -1 4)
les adresses des termes diagonaux étant
idiag : (1 3 6)
c’est-à dire,
" 1 0 !1 %
$ '
A = $ 0 1 !1 ' .
$ '
$# !1 !1 4 '&
Vérifier que la décomposition LDU donne

A (LDU) : (1 0 1 -1 -1 2)
c’est-à-dire,
! 1 0 0 $ " 1 0 !1 %
# & $T '
D=# 0 1 0 & et U = L = $ 0 1 !1 '
#" 0 0 2 &% $ 0 0 1 '
# &
et vérifier la résolution du système Ax = b pour différents seconds membres b.

C.6 L’assemblage

Routines appelées : assembV, assembM, locelem, htcol.

On se donne, sur les deux éléments précédents, des vecteurs et matrices élémentaires et on construit le
vecteur et la matrice globale.

C.6.1 test 1 :

lnods(*,1) : (1,6,5,3)
lnods(*,2) : (6,2,4,5)

1 seul d.d.l par noeud (nequa = 6, nesky = 19)

vecteurs élémentaires :
ve1(i) = 1
ve2(i) = 2 i = 1,...,4

1) matrices élémentaires :

ke1(i,j) = 1 i,j = 1,...,4


ke2(i,j) = 2

vecteur global : (1 2 1 2 3 3)

matrice global : / 1 / 2 / 1 0 1 / 2 0 2 / 1 2 1 2 3 / 1 2 1 2 3 3 /

soit sous forme pleine :


1 0 1 0 1 1
0 2 0 2 2 2
1 0 1 0 1 1
0 2 0 2 2 2
1 2 1 2 3 3
1 2 1 2 3 3
67

2) matrices élémentaires :

ke1(i,j) = 1*i*j i,j = 1,...,4


ke2(i,j) = 2*i*j

matrice globale : / 1 / 8 / 4 0 16 / 12 0 18 / 3 16 12 24 41 / 2 4 8 6 14 6 /

soit, sous forme pleine :


1 0 4 0 3 2
0 8 0 12 16 4
4 0 16 0 12 8
0 12 0 18 24 6
3 16 12 24 41 14
2 4 8 6 14 6

C.7 Le calcul des forces nodales

Routine appelée : solicsuf.

C.7.1 test 1 :
On reprend les deux éléments précédents et on impose des charges uniformes sur les faces constituées
des nœuds 1-6 et 6-2 et une force concentrée au nœud 5.

On se donne donc :
nfacN = 2 nforc = 1
noeuf = 2

lface(*,1) : (1 6) lforc(*) = (5)


lface(*,2) : (6 2)

charg(1) = 1.0 forcc(1) = 9.0


charg(2) = 2.0

Le vecteur des forces nodales équivalentes est alors (les côtés des éléments étant de longueur 1) :

sourc : (0.5 1.0 0.0 0.0 9.0 1.5)

Les forces nodales non nulles sont donc


F1 = 0.5
F2 = 1.0
F5 = 9.0
F6 = 1.5
68

C.8 Des exemples complets

Routines appelées : toutes.

A) Le problème thermique

On considère les deux problèmes suivants qui se différencient seulement par leurs conditions aux
limites et pour lesquels la solution est unidimensionnelle
qx = 0, qy = qy (y)

Problème A.a Problème A.b

la solution est donnée par on a dans ce cas


qy (y) = ry ! K (T1 ! T0 ) ! r 2, qy (y) = ry + qn ,
r r q
T(y) = (y ! y 2 ) + (T1 ! T0 )y + T0 . T(y) = (1 ! y 2 ) + n (1 ! y) + T1 .
2K 2K K

Avec les valeurs particulières de r, K, T1 et T0 ou qn, données sur les figures, les deux problèmes ont la
même solution :
qy (y) = 2y ! 1 et T(y) = !y 2 + y +1.

En particulier la température au centre du carré est T1 = 1,25.


2

C.8.1 test 1 : Exemple avec 4 éléments T3

On utilise le maillage suivant

avec un point d’intégration par élément (nipts = 1). La table de connectivité est la suivante :
lnods(*,1) : ( 1 2 5 ), lnods(*,2) : ( 4 3 5 ),
lnods(*,3) : ( 3 1 5 ), lnods(*,4) : ( 2 4 5 ).

Problème A.a

La seule inconnue est la température au nœud 5 (nequa = 1) : T5. On a alors


iffix : (0 0 0 0 1),
nesky = 6,
idiag : ( 1 ).
69

Les différentes matrices sont, par exemple pour le premier élément,

" 0,5 0 !0,5 %


" 0 %, ! $ $ '
B = $ !1 1 ' D = # 1 0 &, K =$ 0 0,5 !0,5 ' .
# !1 !1 2 & " 0 1 % $ !0,5
# 0,5 1 '&

Les vecteurs élémentaires, après prise en compte des conditions aux limites, sont sur les 4 éléments :

f = (-0.333333333 -0.333333333 1.16666667 ).

La matrice globale est aglob : ( 4 ).

Le vecteur solution est solut : (1.16666667 ).

Noter que la valeur de la température au centre n’est pas la valeur exacte (5/3 au lieu de 5/4), ce qui est
normal puisque la solution exacte est un polynôme du 2e degré et que l’on utilise des éléments linéaires.

La valeur du flux calculée au point d’intégration de chaque élément (le barycentre) est :

q1 = (0,-1/3), q2 = (0,1/3), q3 = (-1/3,0), q4 = (1/3,0).

La procédure de lissage aux nœuds donne :

q1 =(-1/6, -1/6), q2 =(1/6, -1/6), q3 =(-1/6, 1/6), q4 =(1/6, 1/6), q5 =(0,0).

Problème A.b

Les inconnues sont au nombre de nequa = 3 : T1, T2, T5. On a alors

iffix : (1 2 0 0 3),
nesky = 6,
idiag : (1 3 6).

Le calcul des « forces » nodales équivalentes, avant la prise en compte des conditions de Dirichlet
donne :

vglob : (-0.5 -0.5 0.0).

Les différentes matrices locales (B, D, K) sont bien sûr les mêmes que celle du problème précédent.

Les vecteurs élémentaires, après prise en compte des conditions aux limites, sont pour les 4 éléments :

élément 1 : f = ( 0.166666667 0.166666667 0.166666667),


élément 2 : f = (-0.333333333 -0.333333333 1.16666667 ),
élément 3 : f = (-0.333333333 0.166666667 0.666666667),
élément 4 : f = ( 0.166666667 -0.333333333 0.666666667).

La matrice globale est alors aglob : (1 0 1 -1 -1 4)

et qui se décompose sous forme LDU en aglob(LDU) : (1 0 1 -1 -1 2).

Le vecteur solution est solut : (1 1 1.16666667).

Les valeurs des flux sont les mêmes que celles du problème précédent :

q1 = (0,-1/3), q2 = (0,1/3), q3 = (-1/3,0), q4 = (1/3,0).


70

C.8.2 test 2 : Exemple avec 4 éléments T6

On refait le même test mais avec des éléments quadratiques triangulaires à 6 nœuds et on utilise une
intégration numérique à 3 points d’intégration.

La table de connectivité est ici :


lnods(*,1) : (1 2 5 6 7 8), lnods(*,2) : (4 3 5 9 10 11),
lnods(*,3) : (3 1 5 12 8 10), lnods(*,4) : (2 4 5 13 11 7).

Problème A.a

Le nombre d’inconnues est nequa = 7 (celles attachées aux nœuds 5, 7, 8, 10, 11, 12 et 13) et on a
iffix : (0 0 0 0 1 0 2 3 0 4 5 6 7),
nesky = 28,
idiag : (1 3 6 10 15 21 28).

Le vecteur second membre global est


vglob : (-1.33333 3 3 3 3 0.166666667 0.166666667).

Le vecteur solution est


solut : (1.25 1.1875 1.1875 1.1875 1.1875 1.25 1.25).
T5 T7 T8 T10 T11 T12 T13
La solution est cette fois exacte.

Problème A.b

Le nombre d’inconnues est nequa = 10 et on a


iffix : (1 2 0 0 3 4 5 6 0 7 8 9 10),
nesky = 53,
idiag : (1 3 6 10 15 21 28 35 44 53).

Le calcul des « forces » nodales équivalentes, avant et après la prise en compte des conditions de
Dirichlet donne :
vglob : (-0.166666667 -0.166666667 0 -0.666666667 0 0 0 0 0 0),

vglob : (-0.166666667 -0.166666667 -0.666666667 -0.5 0.333333333 0.333333333 3 3 0.166666667


0.166666667).

Le vecteur solution est

solut : (1. 1. 1.25 1. 1.1875 1.1875 1.1875 1.1875 1.25 1.25).


T1 T2 T5 T6 T7 T8 T10 T11 T12 T13
La solution est cette fois exacte.
Le lissage aux noeuds du flux de chaleur est :
q1 = (0,-1/3), q2 = (0,-1/3), q3 = (0,1/3), q4 = (0,1/3), q5 = (0, 0), q6 = (0,-2/3),
q7 = (0,-1/3), q8 = (0,-1/3), q9 = (0,2/3), q10 = (0,1/3), q11 = (0,1/3), q12 = (0, 0).
71

C.8.3 test 3 : Calcul avec plusieurs T3

On vérifie que la solution converge vers la solution exacte avec la taille des éléments. La figure suivante
montre la comparaison avec la solution analytique en utilisant une taille d’élément de h=1/10 :

Répartition de la température sur un profil à x constant.


En rouge la solution analytique, en bleu les valeurs numériques

Représentation en carte de couleurs dans tout le domaine


qui montre que la solution est bien unidimensionnelle.
72

B) Le problème élastique en déformation plane

On considère le problème plan suivant :

On est donc en présence d’un état de contrainte et de déformation homogène. La solution est
$ 0 0 0 ' $ # 0 0 '
& ) 1+# & )
! = & 0 "Fs 0 ), * = Fs & 0 # " 1 0 ) .
E &% 0
& 0 0 "# F ) 0 0 )(
% s (

Le vecteur déplacement est, compte tenu des conditions aux limites,


! (1 + ! ) 1 " !2
ux = Fs x, uy = " Fs y.
E E
Avec les valeurs indiquées sur la figure, on a donc
5 15
! xx = 0, ! yy = "1, ! zz = "0.25, ux = x, uy = " y.
16 16

C.8.4 test 4 : Exemple avec 4 éléments T3

On utilise le même maillage que pour le test C.8.1 :

avec un point d’intégration par élément (nipts = 1). Compte tenu de la linéarité du champ de
déplacement, la solution numérique doit être exacte.
Les conditions aux limites de Dirichlet sont donc les suivantes :
u1x = u1y = 0, u2y = 0, u3x = 0.

Le nombre nequa d’inconnues est donc égale à 6 et on a

iffix : (0 0 1 0 0 2 3 4 5 6),
nesky = 20,
idiag : (1 2 5 9 14 20),
vglob : (0 -0.5 0 -0.5 0 0 ).
f2x f3y f4x f4y f5x f5y

Les matrices B, D et K sont sur le premier élément :


! 0.4 0.2 - 0.2 0.0 - 0.2 - 0.2 $
# &
" !1 0 1 0 % ! 1.2 0.4 0.0 $ # 0.2 0.4 0.0 0.2 - 0.2 - 0.6 &
0 0 # & # -0.2 0.0 0.4 - 0.2 - 0.2 0.2 &
B = $$ 0 !1 0 !1 0 2
',
' D = # 0.4 1.2 0.0 & , K =# &.
# 0.0 # 0.0 0.2 - 0.2 0.4 0.2 - 0.6 &
$# !1 !1 !1 1 2 0 '& 0.0 0.4 &% # -0.2 - 0.2
" - 0.2 0.2 0.4 0.0 &
# &
"# -0.2 - 0.6 0.2 - 0.6 0.0 1.2 &%
73

La matrice globale est :

aglob : (0.8 0.8 0.2 0 0.8 0 0.2 0.4 0.8 -0.8 0.4 -0.8 -0.4 3.2 0.4 -0.8 -0.4 -0.8 0 3.2 ).

Le vecteur solution est :


solut : (0.3125 -0.9375 0.3125 -0.9375 0.15625 -0.46875).
u2x u3y u4x u4y u5x u5y

Les contraintes lissées aux nœuds sont en tout nœud : ( 0 -1 0 -0.25).


On vérifie bien que la solution obtenue, tant en déplacement qu’en contrainte, est la solution exacte.

C.8.5 Problèmes de synthèse

C.8.5.1 La barre trouée (thermique)

Réalisez l’essai suivant :

Comparez votre solution avec celle représentée ci-dessous


74

C.8.5.1 La barre trouée (élasticité)

Réalisez l’essai suivant :

Comparez votre solution en contrainte avec celle représentée ci-dessous.

Pression moyenne (en MPa) Deuxième invariant des contraintes (en MPa)

C.8.5.2 État de contrainte autour d’une excavation

Réalisez l’essai suivant en présence des forces de pesanteur :

Faire le même essai mais sans l’excavation.


75