MISE EN ŒUVRE DE LA

MÉTHODE DES

ÉLÉMENTS FINIS

R. HASSANI 2004 - 2005

_____________________________________________________________________________________________________________________________

Table des matières

Introduction ....................................................................

p 5

Partie A Rappels et généralités

A.1 L’approximation par éléments finis ............................................. p 7 A.1.1 Bases de polynômes .............................................. p 8 A.1.2 Élément réel, élément de référence et transformation géométrique ............. p 8 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,

ou une arête,

#

$%

&%

'e ( e ',

" 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(xp ) et

fe '(xp ) 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. variables

Dim(P) base canonique

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 :

f (x) = Ni(x) fi

i=1

ne

! , x !!n (n < ne),

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 :

Ni(xk ) = !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(y3 ! 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# ! #", N2(!,") = !, N3(!,") = ",

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), ! = (!,") ) :

f (x) = Ni(!) fi

i=1

ne

" , avec x = !e("),

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 :

x = !e(") = Ni(")xi

e

i=1

ne

# , !x "#e.

Les fonctions polynomiales Ni 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 :

x1 = F !1 + c = c, x2 ! x1 = F ("2 ! "1) = F

1

0

#

$%&

'(,

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

Uadm = T :!" !; T(x) = T(x) sur #T{ } et par

U0 = T :!" !; T(x) = 0 sur #T{ } (pour la

régularité du problème on peut supposer que Uadm et Uo sont inclus dans H1(!) ).

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#

$ +

!

T qTn 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 !Uadm telle que

"!

TT#"T dV$

% =

!

T qn dS +

!

T r dV , &!

T !Uo.$

%'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 :

T(x) = Ni

e(x)Tie

i=1

nnode

! , pour tout x "#e ,

où les Ni

e sont les fonctions d’interpolation de l’élément !e ( Ni

e(x) = 0 si x !"e ) et les Ti

e , les valeurs de T aux nnode nœuds de l’élément ( Ti

e= T(xi

e ) , xi

e étant les coordonnées des nœuds de ).

On choisit pour !

T le même type d’approximation (méthode de Galerkin) :

!

T(x) = Nie(x)!

Tie

i=1

nnode

! .

Les gradients de T et de !

T , vecteurs de !ndime sont donc donnés par

!T(x) = Ti

e!Ni

e(x)i=1

nnode

" , !!

T(x) =!

Tie!Ni

e(x)i=1

nnode

" .

La forme variationnelle discrète est alors :

!

Tie Tj

e (!NieT "# !N j

e )$e

%j=1

nnode

& dV ' Nier

$e

% dV ' Nie qn dS

($e )*q

%+

,-

.-

/

0-

1-i=1

nnode

&e=1

nelem

& = 0, 2!

Tie.

La forme discrète s’écrit donc sous la forme :

!Te

T! keTe " fe{ }

e=1

nelem

# = 0, $!

Te = (!

T1e ,...,

!Tnnode

e )T %"nnode ,

où ke est une matrice de dimension nnode % nnode, de composantes

(ke )ij = !NieT "#!N j

e dV$e

% , appelé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 = Nier

!e

" dV + Nie qn dS

#!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 Uadm = u :!" !

n; u(x) = u(x) sur #u{ } et par U0 = 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 !U0 un champ virtuel quelconque. On a alors :

!uT !(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 !Uadm tel que!" :# dV

$

% =!uT

&#

% Fs dS +!uT f

$

% dV , '!u !Uo ,

(

)*

+*

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 !Uadm tel que!" : C " dV

#

$ =!uT

%&

$ Fs dS +!uT f

#

$ dV , '!u !Uo.

(

)*

+*

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

u(x) = (ux (x),uy (x),uz (x))T = Ni

e(x) uie

i=1

nnode

! ,

où ui

e!!

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) = Ne(x) ue , où Ne désigne la matrice de dimension ndime % nnode

Ne = N1

eI N2eI ..... Nnnode

e I!"

#$ ,

I est la matrice unité (ndime % ndime). Soit en 3D :

Ne =

N1e 0 0 N2

e 0 0 ...... Nnnodee 0 0

0 N1e 0 0 N2

e 0 ...... 0 Nnnodee 0

0 0 N1e 0 0 N2

e ...... 0 0 Nnnodee

!

"

####

$

%

&&&&

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 ,u2

e ,...,unnodee )T = (u1

x ,u1y ,u1

z; u2x ,u2

y ,u2z;.....; unnode

x ,unnodey ,unnode

z )T

Noter que le gradient du champ de déplacement, tenseur du second ordre, s’écrit

!u = uie"!Ni

ei# .

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{ }.

Ce vecteur s’écrit donc en fonction des déplacements nodaux : e = Bi

e uie

i=1

nnode

! , où les matrices Bi

e (6 % 3)

sont

Bie=

!xNie 0 0

0 !yNie 0

0 0 !zNie

!yNie !xNi

e 0

0 !zNie !yNi

e

!zNie 0 !xNi

e

"

#

$$$$$$$$$$

%

&

''''''''''

.

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 = B1

e 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) :

D =

2µ + ! ! ! 0 0 0

! 2µ + ! ! 0 0 0

! ! 2µ + ! 0 0 0

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) = Ne(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 :

!ue

T! ke ue " fe{ }

e=1

nelem

# = 0, $!ue %"

ndime&nnode ,

avec

ke =

!e

" BeT D Be dV : la matrice de rigidité élémentaire, de dimension 3nnode % 3nnode,

fe = NeT f

!e

" dV + NeT Fs dS

#!e $%&

" : le vecteur charge élémentaire, de dimension 3nnode

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

D =

2µ + ! ! 0

! 2µ + ! 0

0 0 µ

"

#

$$$$

%

&

''''

.

Quant aux matrices déformation – déplacement, Bie (de dimension 3 % 2), elles s’écrivent

Bie=

!xNie 0

0 !yNie

!yNie !xNi

e

"

#

$$$$

%

&

''''

.

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 :

D =

A B 0

B A 0

0 0 µ

!

"

###

$

%

&&&

avec

A =E

1!"2

et B = ! A,

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 =

!e

" BeT D Be dV et

fe = NeT f

!e

" dV + NeT Fs dS

#!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 :

D = $ , Ne = (N1e ,N2

e ,...,Nnnodee ),

Be =

!xN1e !xN2

e . . !xNnnodee

!yN1e !yN2

e . . !yNnnodee

!zN1e !zN2

e . . !zNnnodee

"

#

$$$$

%

&

''''

.

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,

" nevab pour fe,

" nstri % nevab pour Be,

" nstri % nstri pour D,

" ndofn % nevab pour Ne,

" 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 :

ndime = 2 nnode = 4 nelem = 2 npoin = 6

Table de connectivité :

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

Table des coordonnées : coord(*,1) = (0,0) coord(*,2) = (2,0) coord(*,3) = (0,1) coord(*,4) = (2,1) coord(*,5) = (1,1) 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

npntD = 2 lpntD(1) = 2 lrefpD(1) = 1 lpntD(2) = 4 lrefpD(2) = 1

Condition de Neumann

npntN = 1 lpntN(1) = 5 lrefpN(1) = 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

$#z $%z $& z

'

(

))))

*

+

,,,,

=: JT

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 xi

e en utilisant les mêmes fonctions d’interpolation Ni que l’approximation nodale :

x = Ni xi

e

i=1

nnode

! , y = Ni yie ,

i=1

nnode

! z = Ni zie

i=1

nnode

! (ou x = Ni xie

i=1

nnode

! ),

autrement dit, la transformation géométrique est définie par ! : " ! x = Ni(").xi

e

i=1

nnode

#

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 :

!"x = xi

e !"Nii=1

nnode

# , !"y = yie !"Ni

i=1

nnode

# , !"z = zie !"Ni.

i=1

nnode

#

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

J = !"Ni

i=1

nnode

# $ xie.

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

Si l’on considère maintenant les fonctions F(!) = Ni(!) et f (x) = Ni(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. !xNi , !yNi , !zNi ) en

fonction des dérivées locales (i.e. !"Ni , !#Ni , !$Ni ) par :

!xNi(x) = J (")#$ %&

'1!"Ni(").

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 xi

e des nœuds de l’élément réel :

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

! former la matrice jacobienne J = !"Ni # xi

e

i=1

nnode$ 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.

! En dimension 1 : J !1

=1

J,

J = det J = J11.

! En dimension 2 :

J !1=

1

J

J22 !J12

!J21 J11

"

#

$$

%

&

'',

J = det J = J11J22 ! J12J21.

! En dimension 3 :

J !1=

1

J

J22J33 ! J23J32 J13J32 ! J12J33 J12J23 ! J13J22

J31J23 ! J21J33 J11J33 ! J13J31 J21J13 ! J23J11

J21J32 ! J31J22 J12J31 ! J32J11 J11J22 ! J12J21

"

#

$$$$

%

&

''''

,

J = det J = J11(J22J33 ! J32J23)+ J12(J31J23 ! J21J33)+ J13(J21J32 ! J31J22).

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 !"Ni au point " .

Synopsis :

element_Tria3 (x,y,shape,deriv)

shape(3), deriv(2,3)

où

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 !"Ni .

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

shape(1) = 1.0 - x - y shape(2) = x shape(3) = y

deriv(1,1) =-1.0 deriv(2,1) =-1.0 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 !"Ni 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 !"Ni 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

!"Ni (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

!xNi.

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

où cdnod est un tableau de réels contenant les coordonnées nodales xi

e de l’élément considéré

dcart est un tableau de réels contenant les dérivées cartésiennes gradxNi 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 :

! calcul de la matrice jacobienne : Jpq = (xi

e )q!pNi ,i=1

nnode" 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!e

" = f !#($) det J ($) dV!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 :

g(!) dV"r

# $ g(!k )k=1

nipts

% &k ,

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 » :

g(!,") dV#r

$ = d! g(!,") d"%1

1

$%1

1

$ & 'kk( 'lg(!k ,"l )

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 ( ).

La formule d’intégration se met sous la forme

g(!,") dV#r

$ = d! g(!,") d"0

1%!

$0

1

$ & 'kg(!k ,"k )k( .

Ordre

m nbr de

points nipts coordonnées "k #k

poids )k

1 1 1/3 1/3 1/2

2

3 1/2 0

1/2

1/2 1/2 0

1/6

5

7

1/3 a

1-2a a b

1-2b b

1/3 a a

1-2a b b

1-2b

9/80 A A A B B B

avec a =

6 + 15

21,

b =

4

7! a ,

A =

155 + 15

2400 et

B =

31

240! A.

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

g(!,",#) dV$r

% = d! d"&1

1

% g(!,",#) d#&1

1

%&1

1

% 'k(

l( )k )l )m g(!k ,"l ,#m)

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 :

g(!,",#) dV$r

% =

0

1&!&"

% g(!,",#) d! d" d#0

1&!

%0

1

% ' (kg(!k ,"k ,#k )k) .

37

Ordre m

nbr de points nipts

coordonnées "k #k $k

poids )k

1 1 1/4 1/4 1/4 1/6

2

4 a a a b

a a b a

a b a a

1/24 1/24 1/24 1/24

3

5

1/4 1/6 1/6 1/6 1/2

1/4 1/6 1/6 1/2 1/6

1/4 1/6 1/2 1/6 1/6

!2/15 3/40 3/40 3/40 3/40

avec a =

5 ! 5

20,

b =

5 + 3 5

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

g(!) dV"r

# $ S := g(!k )k=1

nipts

% &k.

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

#$%

&% ou

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

"k = " p"q"r

#$%

&% avec

! j " #1,1$% &' et

! j (j = p, q ou r) obtenus au §B.4.1.

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)

où

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

i! ) mais la structure des données serait alors moins uniforme.

! 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) :

A =

! 0 ! 0 ! !

0 ! 0 ! ! !

! 0 ! 0 ! !

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 =

a11 0 a13 0 a15 a16

0 a22 0 a24 a25 a26

a31 0 a33 0 a35 a36

0 a42 0 a44 a45 a46

a51 a52 a53 a54 a55 a56

a61 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 :

$

A =

! 0 ! 0 ! !

0 ! 0 ! ! !

! 0 ! 0 ! !

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

e(i ! min

kjke )

où ( jk

e )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 : ( jk

1)k=1,..,nnode = (1, 6, 5, 3)!m1 := mink

jk1= 1,

! sur l’élément 2 : ( jk

2)k=1,..,nnode = (6, 2, 4, 5)!m2 := mink

jk2= 2,

d’où, h6 = max

e=1,2(6 !me ) = 6 !1 = 5.

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

!

TeT!

e=1

nelem

" keTe # fe{ } = 0, pour tous les

!

Te admissibles,

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)

Désignons par T le vecteur inconnu T1,T2,T3,T4,T5,T6( )

Tet par

!

T le vecteur (!

T1,!

T2,!

T3,!

T4,!

T5,!

T6)T et

écrivons pour chaque élément e les termes

!

TeT!keTe =

!

Tei ke

ijTej

j=1

4"i=1

4" et

!

TeT! fe =

!

Tei fe

ii=1

4" sous

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

T :

! Élément 1 : T1 = T1

1,T12,T1

3,T14( )

T

= (T1,T6,T5,T3)T et de même pour !

T1,

!

T1T !k1 T1 =

!

T T !

k111 0 k1

14 0 k113 k1

12

0 0 0 0 0 0

k141 0 k1

44 0 k143 k1

42

0 0 0 0 0 0

k131 0 k1

34 0 k133 k1

32

k121 0 k1

24 0 k123 k1

22

"

#

$$$$$$$$$

%

&

'''''''''

T1

T2

T3

T4

T5

T6

(

)

*******

+

,

-------

,

!

T1T ! f1 =

!

T T !

f11

0

f14

0

f13

f12

"

#

$$$$$$$$

%

&

''''''''

.

! Élément 2 : T2 = T2

1,T22,T2

3,T24( )

T

= (T6,T2,T4,T5)T et de même pour !

T2,

!

T2T !k2 T2 =

!

T T !

0 0 0 0 0 0

0 k222 0 k2

23 k224 k2

21

0 0 0 0 0 0

0 k232 0 k2

33 k234 k2

31

0 k242 0 k2

43 k244 k2

41

0 k212 0 k2

13 k214 k2

11

"

#

$$$$$$$$$

%

&

'''''''''

T1

T2

T3

T4

T5

T6

(

)

*******

+

,

-------

,

!

T2T ! f2 =

!

T T !

0

f22

0

f23

f24

f21

"

#

$$$$$$$$

%

&

''''''''

.

46

La relation

!

TeT .ke Tee=1

2! =

!

TeT . fee=1

2! donne alors

!

T T !

k111 0 k1

14 0 k113 k1

12

0 k222 0 k2

23 k224 k2

21

k141 0 k1

44 0 k143 k1

42

0 k232 0 k2

33 k234 k2

31

k131 k2

42 k134 k2

43 k133

+ k244 k1

32+ k2

41

k121 k2

12 k124 k2

13 k123

+ k214 k1

22+ k2

11

"

#

$$$$$$$$$

%

&

'''''''''

T1

T2

T3

T4

T5

T6

(

)

*******

+

,

-------

=

!

T T !

f11

f22

f14

f23

f13+ f2

4

f12+ f2

1

(

)

********

+

,

--------

.

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) :

Kle (i),le ( j)

! K le (i),le ( j)+ ke

i, j , Fle (i)

! Fle (i)+ fe

i , 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 =

!e

" Be(x)T D(x) Be(x) dV et

fe = Ne(x)T f!e

" (x) dV + Ne(x)T Fs(x) dS#!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 :

ke =

!r

" Be(#)T D(#) Be(#) det J(#) dV $ %kBe(#k )T D(#k ) Be(#k ) det J(#k )k=1

nipts

& .

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 :

(ke )ij = !xNieT "#!xN j

e dV$e

% et

( fe )i = Nier

!e

" dV + Nie qn dS

#!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

Ni

e de l’élément, leurs ndime ! nnode dérivées cartésiennes

!xNi

e 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)

(ke )ij = k !xNieT "!xN j

e J#r

$ % &kk=1

nipts

' k((k )!xNie((k )T "!xN j

e((k ) J((k ),

( fevol )i = Ni

e r J!r

" # $kr(%k ) Nie(%k ) J(

k=1

nipts

& %k ),

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

!xNie estimées aux nipts points d’intégration,

les nnode fonctions d’interpolation Ni

e 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)

où 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!kJ("k )#xNi

e("k )T $#xN je("k ) (pour j $ i)

et sommation dans ke : boucle de j = i à nnode

calculer le produit scalaire ps = !xNi

eT"!xN j

e

Alocl(i,j) = Alocl(i,j) + delta * condu * ps fin_boucle_j

2) calcul des termes r !k Nie("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,

Kijj!k" Tj = fi # KikTk , i = 1, ..., n.

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 ! KikTk.

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, + matno, + Alocl,Flocl,cdnod,Tbare, + shape,deriv,dcart,djacb, + cdpti,poids,noeud,locel, + nesky,ndime,npoin,nnode, + 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.

Tableaux globaux

Tableaux élémentaires

Variables de dimensionnement

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

!e

q= "#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!e

q

"

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 !e

q sont nulles. Il s’ensuit que la connaissance de la liste des nœuds formant !e

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

fe = ( f1e , f2

e , f3e , f4

e , f5e , f6

e )T

et si !eq est formée des nœuds 1, 4 et 2 on aura à calculer uniquement :

f1e= N1(x)qn(x) dS

!eq

" ,

f4e= N4(x)qn(x) dS

!eq

" et

f2e= N2(x)qn(x) dS

!eq

"

puisque N3 = N5 = N6 ! 0 sur

!eq.

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 !e

q 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 !e

q :

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

f (x, y) dl!e

q

" ( dl = dx2

+ dy2 ).

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

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

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

f (x, y) dl!e

q

" = f !#($) J($) d$%1

1

" .

Si l’on choisit une transformation # linéaire on a !(") = Ni(")xii=1

2# où les deux fonctions

Ni sont les

fonctions de forme de l’élément linéaire 1D à 2 nœuds : N1(!) = (1" !) 2 , N2(!) = (1+ !) 2.

55

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

12

(x2 " x1)2+ (y2 " y1)2

=12

L, L étant la longueur du côté !e

q.

Finalement,

f (x, y) dl!e

q

" =L

2f !#($) d$

%1

1

" ,

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é !e

q 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= Ni(x)qn(x) dS

!eq

" , pour tout nœud i sur !eq rectiligne

se calcule par

fie=

L

2Ni(!)qn(!) d!

"1

1

# avec L = mes(!eq ).

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 !eq

Le calcul de

fie= Ni(x)qn(x) dS

!eq

" se réduit à

fie=

Lqn

2Ni(!(")) d"

#1

1

$ .

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

La restriction à !eq des fonctions de forme attachées aux 2 nœuds est

Ni(!(")) = 1

2(1 ± ") . On a

donc :

fi

e=

L

2qn.

(la « charge » totale Lqn est distribuée également entre les deux nœuds) .

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

La restriction à !eq des fonctions de forme attachées aux 3 nœuds est

• aux deux extrémités : 12

(!2± !),

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

Les « charges » nodales équivalentes sont donc :

• aux extrémités de !eq :

L

6qn ,

• au nœud milieu :

4L

6qn.

Remarquer que la « charge » totale Lqn est toujours conservée.

56

L’organisation de ces calculs est la suivante :

boucle de e = 1 à nfacN (boucle sur les différentes faces !eq 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!(xk ) , xk correspondant à un nœud du maillage.

Dans ce cas

fie= Ni(x)qn(x) dS

!eq

" = qNi(xk ) = q#ik.

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 " =

12C (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) = DeBe(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 :

xm = Ni

i=1

nnode

! ("k )xie , k=1,...,nipts et m = (e#1) nipts + k,

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

de =

1

niptsde(!k )

k=1

nipts

" ou

de =1

mes(!e )de(x) dV

!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) = Ni(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

i

#k

# ,

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): boucle de ipoin = 1 à npoin

dnodl(ipoin) = 0 conec(ipoin) = 0 fin_boucle_ipoin boucle de e = 1 à nelem delem = 0 boucle de ipnti = 1 à nipts delem = delem + d(ipnti,e) fin_boucle_ipnti delem = delem / nipts

boucle de inœud = 1 à nnode ipoin = lnods(inœud,e) dnodl(ipoin) = dnodl(ipoin) + delem conec(ipoin) = conec(ipoin) + 1 fin_boucle_inœud

fin_boucle_e boucle de ipoin = 1 à npoin dnodl(ipoin) = dnodl(ipoin) / conec(ipoin) 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)T et (#1,1)T et pour valeurs principales '1 = 3.10-3 et '2 =#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.

Initialisation à zéro des di et

d’une table comptabilisant les connections nodales

Calcul de la moyenne des

valeurs calculées aux points d’intégration

Somme des valeurs

moyennes et comptage du nombre de connections

Diviser par le nombre de

connections

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 :

#

I1 =

1

3trace(t), quantité appelée premier invariant de t et qui correspond à la moyenne des

valeurs propres (pour les contraintes on parlera de pression moyenne).

# I2 =

1

2t : t ou

J2 =

12

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 ** ao = 0.680375457, a1 = -0.211234152, a2 = 0.566198468, a3 = 0.596880078 Résultat théorique : 1.73822 quadrature à : 1 point d'intégration Résultat : 1.36075 Erreur relative : 21.71569 % quadrature à : 2 points d'intégration Résultat : 1.73822 Erreur relative : 0.00000 % quadrature à : 3 points d'intégration Résultat : 1.73822 Erreur relative : 0.00000 % quadrature à : 4 points d'intégration Résultat : 1.73822 Erreur relative : 0.00000 %

** Intégration de exp(0.4356*x) ** Résultat théorique : 0.20639E+01 quadrature à : 1 point d'intégration Résultat : 0.20000E+01 Erreur : 0.63852E-01 quadrature à : 2 points d'intégration Résultat : 0.20636E+01 Erreur : 0.26871E-03 quadrature à : 3 points d'intégration Résultat : 0.20639E+01 Erreur : 0.43628E-06 quadrature à : 4 points d'intégration Résultat : 0.20639E+01 Erreur : 0.37501E-09

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 **

P=1 + x + y + x2 + xy + y2 + x3 + x2y + xy2 + y3 Résultat théorique :1.175 (47/40) quadrature à : 1 point d'intégration Résultat : 1.074074074 Erreur relative : 8.589436795 % quadrature à : 3 points d'intégration Résultat : 1.166666667 Erreur relative : 0.709215829 % quadrature à : 7 points d'intégration Résultat : 1.175000023 Erreur relative : 0.000005996 %

** intégration de sin(a*x) * cos(b*y) **

avec a = ' et b = ' / 2

Résultat théorique :0.270189808 (8/3'2) quadrature à : 1 point d'intégration Résultat : 0.375000003 Erreur relative : 38.791320782 % quadrature à : 3 points d'intégration Résultat : 0.284517794 Erreur relative : 5.302933662 % quadrature à : 7 points d'intégration Résultat : 0.270423040 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,

A =

1 0 !1

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,

D =

1 0 0

0 1 0

0 0 2

!

"

###

$

%

&&&

et

U = LT=

1 0 !1

0 1 !1

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 noeuf = 2 lface(*,1) : (1 6) lface(*,2) : (6 2) charg(1) = 1.0 charg(2) = 2.0

nforc = 1 lforc(*) = (5) forcc(1) = 9.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)

la solution est donnée par

qy (y) = ry ! K(T1 !T0)! r 2,

T(y) =r

2K(y ! y2)+ (T1 !T0)y +T0.

on a dans ce cas

qy (y) = ry + qn ,

T(y) =r

2K(1! y2)+

qn

K(1! y)+T1.

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) = !y2

+ y +1.

En particulier la température au centre du carré est T1

2= 1,25.

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 ).

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

69

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

B =

!1 1 0!1 !1 2

"

#$

%

&' ,

D =

1 00 1

!

"#

$

%& ,

K =

0,5 0 !0,5

0 0,5 !0,5

!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 00 "Fs 0

0 0 "#Fs

$

%

&&&

'

(

)))

, * =1+ #

EFs

# 0 00 # "1 00 0 0

$

%

&&&

'

(

))).

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

ux =

!(1+ !)

EFsx, uy = "

1"!2

EFsy.

Avec les valeurs indiquées sur la figure, on a donc

! xx = 0, ! yy = "1, ! zz = "0.25, ux =

5

16x, uy = "

15

16y.

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= u1

y= 0, u2

y= 0, u3

x= 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 :

B =

!1 0 1 0 0 00 !1 0 !1 0 2

!1 !1 !1 1 2 0

"

#

$$$

%

&

'''

,

D =

1.2 0.4 0.0

0.4 1.2 0.0

0.0 0.0 0.4

!

"

###

$

%

&&&,

K =

0.4 0.2 -0.2 0.0 -0.2 -0.2

0.2 0.4 0.0 0.2 -0.2 -0.6

-0.2 0.0 0.4 -0.2 -0.2 0.2

0.0 0.2 -0.2 0.4 0.2 -0.6

-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