mef++ v4.0: les grands concepts - accueil - giref · · 2017-02-15mef++ v4.0 : les grands...

MEF++ v4.0: Les grands concepts 7 novembre, 2006

http://www.giref.ulaval.ca Éric Chamberland Robert Guénette

http://www.giref.ulaval.ca/

MEF++ v4.0 : Les grands concepts

Table des matières 1. Introduction ............................................................................................................................................ 3 2. Les grands concepts................................................................................................................................ 5 3. Les données d’entrées d’un problème .................................................................................................... 6

3.1 Vue d’ensemble de la résolution d’un problème ............................................................................ 6 3.2 La géométrie ................................................................................................................................... 7 3.3 Entité géométrique.......................................................................................................................... 9 3.4 Relation Géométrie / Entités géométriques / Matériaux............................................................... 11 3.5 Relations Géométrie / Entités géométriques / Conditions aux limites.......................................... 11 3.6 Les conditions aux limites ............................................................................................................ 12

3.6.1 Dirichlet................................................................................................................................ 12 3.6.2 Neumann............................................................................................................................... 12 3.6.3 Robin .................................................................................................................................... 13

3.7 Le maillage ................................................................................................................................... 13 3.7.1 Maillage de Peau .................................................................................................................. 14 3.7.2 Coquille ................................................................................................................................ 15

3.8 Hiérarchie d’éléments................................................................................................................... 15 3.9 Les connectivités de base ............................................................................................................. 16 3.10 Les champs ................................................................................................................................... 18

3.10.1 Les champs de transformation géométrique ......................................................................... 19 3.10.2 Les champs éléments finis avec DDL................................................................................... 20 3.10.3 Les champs analytiques ........................................................................................................ 24 3.10.4 Les lois de comportement..................................................................................................... 25 3.10.5 Les champs définis par morceaux de géométrie ................................................................... 25 3.10.6 Les champs avec un changement de repère .......................................................................... 26 3.10.7 Les champs d’empilement .................................................................................................... 27 3.10.8 Les champs d’extension de peau .......................................................................................... 27 3.10.9 Les champs de coquille......................................................................................................... 28

3.11 Relations Géométrie/Entités Géométriques/Maillage/Champ ...................................................... 28 3.12 Schéma d’intégration.................................................................................................................... 30 3.13 Corps ............................................................................................................................................ 31

4. Formulation variationnelle et résolution d’un problème ...................................................................... 33 4.1 Détails de la résolution d’un problème ......................................................................................... 33

4.1.1 Lecture des données.............................................................................................................. 33 4.1.2 Initialisation des termes de formulation................................................................................ 33 4.1.3 Ajout des termes de formulation à l’objet « problème »....................................................... 33 4.1.4 Assemblage et résolution du système global ........................................................................ 33 4.1.5 Exportation des résultats....................................................................................................... 34

4.2 Concept de « problème » .............................................................................................................. 34 4.3 Terme de formulation ................................................................................................................... 36

4.3.1 Types de termes de formultaion............................................................................................ 38 4.4 Rôles d’un terme de formulation .................................................................................................. 39

4.4.1 Assignation des champs et d’un schéma d’intégration ......................................................... 39 4.4.2 Couplage............................................................................................................................... 42 4.4.3 Méthode : TF*::ajouteEvaluationsAFaire(…)...................................................................... 43 4.4.4 Types d’informations locales................................................................................................ 46

4.4.4.1 InfoLocalesTransformation .............................................................................................. 46 4.4.4.2 InfoLocalesInterpolation................................................................................................... 47 4.4.4.3 InfoLocalesChamp............................................................................................................ 48

4.4.5 Méthode : TF*::transfertInformationPourCalculSurElement(…)......................................... 48 4.4.6 Méthode TF*:: evalueIntegrale (...) ...................................................................................... 50

4.5 Hiérarchie de champs ................................................................................................................... 50 4.6 Pré/Post-traitement ....................................................................................................................... 53

4.6.1 PPResolutionProbleme ......................................................................................................... 54

2


1. Introduction Bienvenue dans le monde de MEF++. La programmation orientée objets et les éléments finis sont 2 domaines desquels émerge MEF++. Le logiciel a vu le jour en 1996 à l’Université Laval au sein du Groupe interdisciplinaire de recherche en éléments finis (GIREF) en tant que projet de développement commun qui permettrait aux chercheurs du groupe d’avoir une librairie commune de développement et donc de partager facilement les nouvelles contributions. Depuis ce temps, MEF++ a beaucoup évolué. Partant de la version 1.0 et des nombreux conseils des utilisateurs pour tenter d’en améliorer l’utilisation et l’apprentissage, la version 2.0 est née en 2001. Par la suite, plusieurs projets des membres du GIREF ont utilisé et amélioré le logiciel, en plus de la contribution des étudiants et de stagiaires d’été. Durant 5 ans, la version est restée à 2.0 malgré les nombreux ajouts effectués. C’est en 2006, après la parallélisation du code, l’ajout du code de Corps et nombreuses autres ajouts, que la version 4.0 est apparue (la version 3.0 étant celle qui aurait dû être déclarée après la parallélisation) Les nombreuses améliorations par rapport à la version 1.0 devraient permettre à l’usager du logiciel d’obtenir des résultats de développement plus rapidement. En ayant beaucoup amélioré l’utilisation de haut niveau, l’usage des classes existantes s’est énormément simplifié. Parmi ces améliorations importantes, notons les suivantes : Version 4.0 :

• Ajout du code de Corps (pour le contact par exemple) • Ajout de la notion de Critères de Convergence • Nouveaux types d’interpolation • Restructuration des tests de validation • Parallélisme de la résolution • Parallélisme de la construction de la géométrie • Parallélisme du code de Corps • Compilation avec GCC 3.2, 3.3 et 4.1, ICC 9.1 • Fonctionnel en 64 bits

Version 2.0 :

• Pas de notion de « visiteur » à apprendre • Simplification de l’interface des champs • Uniformisation de la lecture des données dans les programmes • Élimination de la dualité MatriceGlobale/MatricePETsc • Utilisation de egcs 2.95.2 • Diminution du nombre de classes à compiler • Simplification de la structure des répertoires • Ajout du support pour les matériaux • Ajout de mécanique pour les problèmes non linéaires • Ajout de mécanique pour les problèmes instationnaires • Ajout de mécanique pour les problèmes non linéaires instationnaires • Ajout de mécanique pour les problèmes à plusieurs variables (couplés et plus)

De plus, avec l’aide de iMEF++ pour préparer les problèmes, l’utilisation, la création et la gestion des données des problèmes sont grandement facilitées. Il y aura toujours place à l’amélioration pour cet outil issue de nombreuses années de travail. MEF++ est un outil en constante évolution par les ajouts qui y sont faits par les usagers, poussée par les besoins de la

3


recherche. Ainsi, d’autres améliorations sont encore possibles, il ne manque que vous pour les façonner! Vous aurez l’occasion d’apprendre MEF++ et d’y apporter votre contribution personnelle. Selon un proverbe bien connu, il vaut mieux apprendre à pêcher à celui qui a faim plutôt que de lui donner un poisson! Il vous faudra donc investir un peu de temps pour comprendre les grands concepts qui sont présents dans MEF++ et comment ils sont reliés entre eux. Bon apprentissage!

4


2. Les grands concepts Afin de bien comprendre MEF++ v4.0, il faut d’abord illustrer les concepts qui y sont implantés ainsi que les relations entre ces concepts. Étant donné qu’il y a plusieurs aspects importants dans la résolution d’un problème par éléments finis, il faut en comprendre un minimum afin de pouvoir utiliser correctement les outils développés dans MEF++. MEF++ touche pratiquement à tous les aspects d’un problème d’éléments finis et il possède des classes et des fonctions permettant le traitement de chacun de ces aspects. MEF++ est programmé dans un langage orienté objets et utilise les avantages de cette approche. Pour bien situer MEF++ dans un contexte de résolution de problèmes, il faudrait le positionner comme étant l’outil de simulation qui prend le problème à la sortie du logiciel de CAD, après avoir obtenu un maillage de ce dernier, et qui l’amène jusqu’à la visualisation des résultats, en passant par la résolution d’un problème. Vous trouverez dans les pages suivantes une description la plus visuelle possible des principales classes présentes dans MEF++ ainsi que de leurs rôles et de leurs interactions. Il est important aussi de noter la nomenclature utilisée dans le programme, car elle peut différer de celle à laquelle vous pouvez être habitués. Pour bien accompagner ce document, vous pouvez visionner en même temps la présentation « MEF++v4.0 : Les grands concepts » de laquelle nous avons extrait quelques diapositives. (Vous trouverez cette présentation à l’adresse suivante : http://www.giref.ulaval.ca/coursmefpp.) Aussi, afin de mettre en pratique les connaissances acquises ici, vous pouvez suivre le guide d’apprentissage « Didacticiel MEF++ v4.0 » disponible à cette adresse : http://www.giref.ulaval.ca/coursmefpp. Le présent document est prévu pour être utilisé avec ce dernier et est divisé en 2 parties : « Les données d’entrées d’un problème » et « Formulation variationnelle et résolution d’un problème ».

5

http://www.giref.ulaval.ca/coursmefpp/mefpp_grandconcepts.ppt

http://www.giref.ulaval.ca/coursmefpp/Didacticiel.doc


3. Les données d’entrées d’un problème Cette partie du document fait une description des concepts reliés aux données d’entrée pour la résolution d’un problème avec MEF++. Nous mettrons en évidence les liens entre les différents concepts utilisés.

3.1 Vue d’ensemble de la résolution d’un problème Avant de commencer à expliquer tous les concepts qui existent dans le code, voici une description de la vue globale que l’on peut avoir du code MEF++ :

Figure 1 Vue d'ensemble d'un problème

1. Tout commence lorsque vous avez un problème à résoudre. Il vous faut d’abord formuler ce problème, poser les équations qui entrent en jeu, décrire les paramètres du problème (type de matériau, constantes du problème, etc) et les conditions aux limites. 2. Ensuite, si vous choisissez de résoudre votre problème à l’aide de la méthode des éléments finis, il faut discrétiser le domaine à simuler. Cela peut se faire à l’aide d’outils comme les logiciels de CAO ou des mailleurs. À la fin de cette étape, vous aurez au minimum un maillage d’éléments qui ne contient que des coordonnées et des connectivités. Ici entre en jeu MEF++ ou plus précisément iMEF++ : 3. Il vous faut maintenant lire le maillage que vous avez créé à l’étape précédente et « recréer » la géométrie sur ce maillage à l’aide de iMEF++. Cette étape est très particulière à MEF++, car le logiciel n’a pas de module de mailleur et doit donc procéder de façon inverse. C’est sur cette géométrie que nous travaillerons pour la définition des conditions aux limites et des matériaux. Sur la géométrie, les endroits qui nous intéressent seront identifiés comme des « entités géométriques ». 4. À l’aide de iMEF++, on écrit (exporte) les données nécessaires à la résolution : la géométrie (.geom) , le maillage (.mail) , les entités géométriques (.enti). Ensuite, à l’aide de iMEF++ ou à la main, on va écrire un fichier de conditions aux limites (.CL) ainsi qu’un fichier de champs et de matériaux (.champs). Ces 5 fichiers sont typiquement ce que tout programme principal demande pour une résolution de problème.

6


5. Ensuite, on lance le programme MEF++ désiré. Celui-ci fera la lecture des 5 fichiers d’entrée, fera les assemblages nécessaires ainsi que la résolution du système obtenu. Une fois ce travail complété, il va écrire (exporter) les résultats pour permettre la visualisation. 6. Pour la visualisation, on peut utiliser iMEF++ ou tout autre visualisateur supporté par le code MEF++. Le plus utilisé est VU, développé au CERCA () 7. Le problème a été résolu et on peut maintenant valider les résultats avec la pratique ou avec la théorie. Comme on peut le voir, MEF++ entre en jeu à partir de l’étape #3 de la résolution d’un problème. C’est un choix qui a été fait de ne pas avoir de mailleur dans le logiciel, car il en existe beaucoup sur le marché. Le code MEF++ devrait donc pouvoir aider à presque toutes les étapes de la résolution d’un problème.

3.2 La géométrie La géométrie est un aspect fondamental de MEF++. La géométrie se veut la représentation de l’objet à discrétiser. La géométrie proprement dite ne contient pas de maillage. C’est une « définition » de l’objet que l’on veut représenter. Par exemple, on va parler de la géométrie d’une poutre, qui consistera à représenter tous les détails de cette poutre par des points, des courbes et des surfaces suffisamment riches pour bien la représenter. Étant donné une géométrie, on peut avoir plusieurs maillages qui s’y rattachent. Une géométrie est donc a priori indépendante des maillages. Un maillage se veut donc une discrétisation particulière d’une géométrie donnée. De plus, le logiciel iMEF++ inclut des fonctionnalités pour gérer les maillages qui portent sur une même géométrie.

Figure 2 Exemples de géométries simples

7


Figure 3 Les maillages sont liés à leur géométrie

Figure 4 Une géométrie peut servir de support à plusieurs maillages

Une géométrie est donc composée de points, courbes, surfaces et volumes. Si l’on faisait porter des numéros à ces points, courbes et surfaces dans le cas de la géométrie en forme de fer à cheval, combien aurions-nous de chacun de ces objets?

8


Figure 5 Détails des composantes d'une géométrie

Notez qu’il est possible d’avoir des courbes complexes comme la courbe « c5 » dans l’exemple ci-haut.

Figure 6 Détails des composantes d'une géométrie (3D)

Dans MEF++, chacun de ces points, courbes, surfaces et volumes est ce que l’on appelle un lieu géométrique (la classe « LieuGeometrique »).

3.3 Entité géométrique La notion d’entité géométrique est simplement un regroupement de lieux géométriques. C’est une notion (en fait la classe « EntiteGeometrique ») qui représente un groupe de lieux géométriques et qui est surtout utilisée pour imposer les conditions aux limites et faire des associations de matériaux. Une entité portera le nom que l’usager aura choisi et qui pourra représenter le nom du morceau de la pièce qu’il représente (Ex : « Entrée » pour l’entrée d’un tuyau).

9


Figure 7 Les entités géométriques sont composées de lieux géométriques

Les entités géométriques sont en lien direct avec la géométrie sur laquelle elles sont définies. Une géométrie peut avoir plusieurs entités géométriques définies sur elle-même. Tous les maillages reliés à cette géométrie peuvent utiliser automatiquement les entités définies sur cette dernière, c’est-à-dire que, si l’on définit l’entité géométrique « Entrée » qui est constituée de 2 points et de 1 courbe, lorsque l’on décide d’appliquer une condition aux limites sur cette entité, les bons nœuds de calcul associés à cette entité par l’intermédiaire du maillage et du champ sont automatiquement sélectionnés. De plus, il est à noter que l’usager peut ajouter autant d’entités géométriques qu’il le désire et que celles-ci peuvent même être redondantes. C’est l’usager qui va décider par la suite quelles seront les entités dont il voudra se servir pour ses conditions aux limites ou selon les matériaux. Voici d’autres exemples d’entités géométriques sur le maillage avec un insert :

Figure 8 Exemples d'entités géométriques

L’usager pourra ici choisir 2 matériaux différents pour les 2 entités géométriques « matInt » et « matExt ». Par exemple, l’entité « matInt » pourrait être associée à de l’acier et l’entité « matExt » pourrait être associée à du bois. De plus, il est possible d’ajouter ce que l’on appelle les changements de repère à une entité géométrique, c’est-à-dire qu’il est possible de définir un changement de repère cylindrique pour un

10


matériau comme le bois en assignant, par exemple, un changement de repère cylindrique à l’entité géométrique « matExt ». L’avantage de travailler avec une géométrie et des entités géométriques est que, si vous préparez les données pour faire une simulation, ces données sont conservées sans être en lien direct avec un maillage. Si vous changez de maillage, vous pouvez donc réutiliser les données de votre problème (conditions aux limites, matériaux, changements de repère), ce qui vous permet de tester rapidement plusieurs maillages pour les mêmes conditions de simulation.

3.4 Relation Géométrie / Entités géométriques / Matériaux Dans MEF++, il est aussi possible de traiter des problèmes avec différents matériaux. Comme les conditions aux limites, les matériaux sont associés à des entités géométriques. Donc, on pourra réutiliser la même distribution de matériaux pour plusieurs maillages, pour autant qu’ils portent tous sur la même géométrie.

Figure 9 Relations entre la géométrie, les entités et les matériaux

3.5 Relations Géométrie / Entités géométriques / Conditions aux limites Maintenant que vous avez vu l’avantage de travailler avec une géométrie et des entités géométriques plutôt que directement avec un maillage, voyons ce que vous pouvez faire avec des entités géométriques. La première utilisation d’une entité géométrique est l’imposition de conditions aux limites. Pour imposer des conditions aux limites à un problème, il faut d’abord créer les entités géométriques afin de regrouper les morceaux de géométrie qui porteront ces conditions aux limites. En ayant choisi des noms représentatifs (ex. : « Entrée », « Sortie », « Haut », « Bas », etc.) pour vos entités géométriques, le lien avec les conditions aux limites devient plus près du langage écrit. Par exemple, si l’on veut imposer une température de 100 °C à l’entrée, on dira : « J’impose 100 °C à l’entrée » et, dans les faits, on va lier la condition limite de Dirichlet T = 100 à l’entité géométrique « Entrée ». Vous remarquerez que, jusqu’ici, on n’a pas parlé d’interpolation du champ auquel est reliée la condition aux limites. En fait, les conditions limites sont a priori indépendantes du type d’interpolation choisi, donc indépendantes d’un champ en particulier. C’est seulement lorsque l’on affectera des conditions aux limites pour un problème précis que celles-ci seront imposées aux bons nœuds de calcul.

11


Figure 10 Relations entre la géométrie, les entités et les conditions aux limites

3.6 Les conditions aux limites Dans MEF++, il y a 4 types principaux de conditions aux limites : - Les conditions de Dirichlet - Les conditions de Neumann - Les conditions de Robin (aussi appelées Neumann non-linéaire) - Pressions suiveuses Avant tout, il est important de savoir que le code MEF++ a été conçu a priori pour calculer la correction à une valeur initiale et non calculer directement une solution finale.

3.6.1 Dirichlet La condition de Dirichlet est la plus simple. Elle vise à imposer directement la valeur de la solution sur les nœuds de calculs spécifiés. Par exemple, on imposera une température de 100 °C sur une partie de la géométrie. Beaucoup de codes d’éléments finis préfèrent éliminer les noeuds de calculs (DDLs) imposés afin de calculer seulement les noeuds libres du système. Cela nécessite une connaissance des conditions aux limites au niveau de l'assemblage. Le code MEF++ procède autrement. On assemble une matrice globale et un vecteur global sans spécifier les conditions aux limites. Ensuite on modifie la matrice et le résidu du système afin de tenir compte des CL de Dirichlet.

3.6.2 Neumann Dans MEF++, on peut facilement imposer une condition aux limites de Neumann. Tout comme les conditions aux limites de Dirichlet, elles sont imposées une fois le système assemblé. Par exemple, pour imposer une condition aux limites de Neumann valant (peut être scalaire, vectoriel ou tensoriel), on aura une contribution au résidu élémentaire donnée par:

12


La forme de la condition de Neumann (ou condition naturelle) varie avec l’équation aux dérivées partielles. Par exemple, pour imposer un flux sortant avec l’équation de la diffusion de la chaleur (laplacien), on aurait :

donc

3.6.3 Robin Il est aussi très facile d’imposer une condition aux limites de Robin, qu’elle soit linéaire ou non (aussi appelé Neumann non-linéaire). Pour imposer une condition aux limites de Robin valant h(u) (peut être scalaire, vectoriel ou tensoriel), on aura une contribution à la matrice donnée par:

et au résidu donnée par :

Notez que la dérivée de h est calculée symboliquement par le code. Aussi, dans un problème couplé, la fonction h peut dépendre de plusieurs variables et la linéarisation est automatiquement faite (et les termes couplés nécessaires sont ajoutés automatiquement) Par exemple, pour imposer une condition de radiation, on aurait :

donc

3.7 Le maillage Le maillage est constitué de plusieurs listes. Il contient une liste de sommets et d’éléments, mais aussi une liste d’arêtes et de faces. Fait à noter, tout est prévu pour obtenir des mélanges d’éléments de toutes les dimensions dans un même maillage. Il a donc fallu ajouter une notion supplémentaire pour distinguer les côtés des éléments à 2 dimensions et à 3 dimensions, soit les arêtes et les faces. Il existe donc aussi la notion d’arête (« Arete »), et de face à 3 ou 4 côtés (« Face »). Une particularité de la liste de faces est le fait que l’on retrouve des faces à 3 côtés ainsi que des faces à 4 côtés dans la même liste. Ceci n’est pas un « tableau » de connectivité, mais bien une liste d’objets « Face ». Même si une face peut avoir 3 ou 4 côtés, elle demeure une face.

13


C’est la même chose pour la liste des éléments. On y retrouve les 6 types d’éléments décrits au point 3.8 ci-dessous. Encore une fois, la liste des éléments n’est pas un « tableau » de connectivité, mais bien une liste d’objets « Element ». Puisque toutes les classes d’éléments héritent du parent « Element », on peut les traiter ainsi. Dans la liste d’éléments, on retrouve les éléments ordonnés par type. L’ordre est le suivant : - Element1D - ElemTriangle - ElemQuad - ElemTetra - ElemHexa - ElemPrismeTri

Figure 11 Le contenu de la classe «Maillage»

3.7.1 Maillage de Peau Depuis que MEF++ a commencé à traiter des problèmes de contact, la notion de maillage de peau a été introduite. Le maillage de Peau (Γp)est en soit un maillage au sens orienté-objet, donc il hérite de la classe maillage. Là où il est différent du maillage, c’est qu’il contient une liste de correspondance entre les éléments de peau (Γp) et les faces/arêtes du maillage d’origines (Γ). Un des intérêts du maillage de peau est qu’il est possible d’utiliser des champs définis sur le maillage complet (Ω) et de les interroger sur le maillage de peau (Γp). On y reviendra en plus loin.

Figure 12 Le contenu de la classe MaillagePeau

14


3.7.2 Coquille La notion de coquille (Ωc) pourrait aussi se nommer « sous-maillage ». La coquille, comme le maillage de peau, hérite de la classe maillage. C’est donc un maillage utilisable à part entière dans un calcul ou tout autre algorithme de MEF++. Elle a été créée pour l’adaptation de maillage, mais elle a aussi été utilisée pour faire des calculs dans lesquels le domaine était divisé en 2, et certaines inconnues n’existaient que dans 1. Dans cet utilisation, un problème de ferro-fluide , le champ magnétique se propage dans un fil de cuivre et un ferro-fluide (donc dans tout Ω), alors que la vitesse du fluide n’est évidemment présente que dans la partie ferro-fluide du domaine (Ωc).

Figure 13 Le contenu de la class Coquille

3.8 Hiérarchie d’éléments Qu’est-ce qu’un élément? On pourrait trouver beaucoup de réponses à cette question selon la personne à qui on la pose. Il vaut donc la peine de s’arrêter un peu pour bien comprendre la signification du mot « élément » dans le logiciel MEF++. Dans MEF++, un élément n’est rien d’autre qu’une forme géométrique (topologie), une connectivité entre des sommets, des arêtes ou des faces. Plus précisément, on pourrait dire qu’un élément est la connectivité minimale nécessaire pour représenter la forme d’un élément. Ainsi, il n’y a que 6 formes d’éléments disponibles dans MEF++ : les éléments à une dimension (« Element1D »), les éléments triangulaires (« ElemTriangle »), les éléments quadrangulaires (« ElemQuad ») en dimension 2, les éléments tétraédriques (« ElemTetra »), les éléments prismatiques à base triangulaire (« ElemPrismeTri ») et les éléments hexaédriques (« ElemHexa ») en dimension 3. Voici sous forme de hiérarchie la représentation de ces classes :

15


Figure 14 Hiérarchie des éléments

Vous remarquerez qu’il existe une relation entre les 6 sortes d’éléments du fait qu’ils sont tous des héritiers (enfants) de la classe « Element ». Par contre, les classes « Sommet », « Arete » et « Face » ne sont pas considérées comme des éléments. C’est un choix qui a été fait au tout début de la conception du logiciel et qui est demeuré tel quel. Les arêtes et les faces de tous les éléments d’un maillage sont conservées dans des listes différentes des éléments, ce qui vous permet, par exemple, de boucler sur les arêtes d’un maillage. Il est aussi possible de boucler sur un type d’élément en particulier (ex. : « ElemTriangle »).

3.9 Les connectivités de base MEF++ offre une connectivité de base pour les éléments, faces et arêtes. Il existe aussi les connectivités inverses, mais elles doivent être construites sur demande (voir la classe « ConnectiviteInverse » : https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/) Dans le modèle objets de MEF++, les éléments, faces, arêtes et sommets ont des liens entre eux. Pour les arêtes, la connectivité est simple. Elle consiste en un lien (pointeur) vers 2 sommets. Il est donc possible de demander à une arête les 2 sommets qu’elle « possède ». Il faut noter que l’arête ne conserve qu’un pointeur vers ses 2 sommets. Ces 2 sommets sont des objets séparés de l’arête, qui sont dans la liste des sommets du maillage. Il est nécessaire que chaque sommet soit défini séparément d’une arête, puisqu’ils peuvent être utilisés ou référés par plusieurs arêtes.

16

https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/


Figure 15 Connectivité entre les arêtes et les sommets

En plus des arêtes, il y a aussi les faces qui, elles, conservent un lien (pointeur) vers les arêtes qui la composent. Pour chaque face, on a donc un nombre de liens qui correspond au nombre d’arêtes qui définissent la face. Il faut noter que les arêtes sont des objets qui existent séparément de la face. La face ne conserve donc qu’un pointeur vers ses arêtes, puisqu’une arête peut être en lien avec plusieurs faces :

Figure 16 Connectivité entre les faces, arêtes et sommets

Finalement, les éléments ont aussi des liens vers les sommets, arêtes et faces qui les composent. Pour un élément unidimensionnel (« Element1D »), il y a des liens seulement vers des sommets. Pour un élément bidimensionnel (« ElemTriangle » et « ElemQuad »), il y a des liens vers des sommets et des arêtes. Pour un élément tridimensionnel (« ElemTetra », « ElemHexa » ou « ElemPrismeTri »), il y a des liens (pointeurs) vers des sommets, arêtes et faces. Donc, pour un tétraèdre, il y aura 4 liens vers des sommets, 6 liens vers des arêtes et 4 liens vers des faces :

17


Figure 17 Connectivité entre un élément tétraédrique, les faces, les arêtes et les sommets

En regardant la connectivité d’un élément (Figure 17), vous vous demandez peut-être pourquoi un élément conserve des liens vers ses faces, ses arêtes et ses sommets, alors que s’il conservait uniquement des liens vers ses faces cela serait suffisant. C’est une observation juste. Toutefois, il y aurait un travail supplémentaire à faire pour retrouver les sommets qui composent un élément. Ce travail supplémentaire est dû au fait qu’il faudrait « déduire » quels sont les sommets d’un élément à partir de ses faces à chaque fois, si on ne veut pas conserver de liens vers ces sommets. Pour éviter ce travail, on utilise un peu plus de mémoire.

3.10 Les champs Qu’est-ce qu’un « champ »? Ce concept très important dans MEF++ est au cœur de tous les programmes que vous allez utiliser ou programmer vous-mêmes. Il est donc important de bien comprendre ce concept incontournable. D’abord, le concept de champ réunit 2 choses : • les données (ex :degrés de liberté, fonction analytique, propriété de matériau); • les fonctions (méthodes) que l’on peut utiliser sur ces données. Tous les champs de MEF++ sans exception sont capables de s’interpoler sur un élément, étant donnée une coordonnée de référence. À ce chapitre, le concept de champ est beaucoup plus qu’un simple « vecteur » de degrés de liberté. Pour les champs avec DDLs, c’est aussi une combinaison, ou liaison entre les degrés de liberté et les fonctions d’interpolation. Pour les champs qui calculent des propriétés physiques, c’est une liaison entre une loi de comportement et les variables dont elle dépend pour se calculer. Enfin, puisque dans MEF++ tout est prévu pour le mélange de différents types d’éléments, les champs sont aussi prévus pour calculer sur tous les types d’éléments (sauf pour quelques exceptions). Notez qu’il existe aussi le concept de champ analytique, qui ne comporte ni degré de liberté ni fonction d’interpolation, mais il est quand même désigné comme un « champ ». Il existe 9 grandes catégories de champs dans MEF++ :

1. Les champs de transformation géométrique (ex. : « ChampGeoLin ») 2. Les champs éléments finis avec DDL (ex. : « ChampScalLin »)

18


3. Les champs analytiques (ex. : « ChampSAExpAlg ») 4. Les lois de comportement (ex : « ChampSolideHookeenConstant ») 5. Les champs définis par morceaux de géométrie (ex. :

« ChampContinuSurGeometrie<ChampScalContinu> ») 6. Les champs avec un changement de repère (ex. : « ChampTensO4SymChangRepere ») 7. Les champs d’empilement (ex. : « ChampV3DAEmpilement ») 8. Les champs qui « vivent » sur les points d’intégrations 9. Les champs d’extension de peau/coquille

3.10.1 Les champs de transformation géométrique Maintenant que vous avez vu qu’un élément n’était qu’une forme géométrique, une connectivité, vous vous demandez sans doute comment utiliser ce concept d’élément pour faire, par exemple, des éléments courbes. À la base dans MEF++, tous les maillages ont des éléments droits, des arêtes droites et des faces planes. Le concept de transformation géométrique des éléments est un concept séparé, distinct en soi. Il appartient à l’utilisateur de faire porter ou non une courbure sur l’élément. C’est quelque chose que l’on « ajoute » à un élément géométrique. La transformation de l’élément réel vers l’élément de référence, pour des éléments droits ou courbes, est un concept qui est disponible dans MEF++. Ce concept s’appelle champ géométrique (« ChampGeometrique »). Il permet à un élément d’avoir une courbure et permet surtout de calculer la matrice jacobienne de transformation de l’élément réel vers l’élément de référence. Pour pouvoir avoir des éléments courbes, il faut plusieurs choses : • le maillage droit; • la géométrie définie à partir de ce maillage. Avec le maillage et la géométrie, il est possible de calculer la position (par une projection) des milieux des arêtes du maillage droit. On conserve ces positions dans le « ChampGeoQuad », qui est distinct du maillage.

Figure 18 Les champs de transformation géométrique

Aussi, la fonction la plus importante du champ géométrique est sans doute le calcul des matrices jacobiennes de transformation. Ainsi, étant donnés un élément et une coordonnée de référence, le champ géométrique peut donner la matrice jacobienne pour ce point. Cette matrice jacobienne sera utilisée plus

19


tard dans le calcul élémentaire et aussi pour transformer les dérivées premières et secondes des fonctions de base de l’élément de référence vers l’élément réel. Le champ géométrique possède donc des fonctions d’interpolation qu’il interroge pour pouvoir calculer la matrice jacobienne. On va retrouver le même concept de fonction d’interpolation autant dans le champ géométrique que dans les champs éléments finis. Toutefois, il faut bien comprendre que les fonctions d’interpolation du champ géométrique sont utilisées avec les nœuds géométriques. Voici un exemple de code MEF++ où l’on « ajoute » le champ géométrique à un maillage : ------------------------- Maillage lMail; ... // On crée un objet de type ChampGeoLin en lui passant le maillage // auquel on veut qu’il soit lié. ChampGeoLin lChampGeo(lMail); ... // On peut maintenant utiliser ce champ géométrique pour // demander la matrice jacobienne en une coordonnée de référence. lChampGeo.reqMatriceJacobienne(lElement, lCoorRef, lMatriceJacobienne); ... -------------------------

3.10.2 Les champs éléments finis avec DDL Maintenant que nous avons une transformation géométrique pour les éléments, il reste 2 concepts importants à ajouter aux éléments géométriques, soit les concepts d’interpolation et de nœuds de calcul. Bien qu’avec un champ géométrique les éléments aient déjà des fonctions d’interpolation pour la transformation géométrique, celles-ci peuvent être différentes des fonctions d’interpolation utilisées pour la fonction approchée. Elles peuvent être isoparamétriques, pseudo-isoparamétriques, sub-paramétriques ou super-paramétriques. Comme la transformation géométrique, les concepts d’interpolation et de noeuds de calcul sont des choses que l’on « ajoute » à un élément géométrique. L’usager peut donc choisir de faire porter une interpolation quadratique avec des degrés de liberté scalaires sur les éléments d’un maillage. À ce jour, il y a 22 types d’interpolation disponible dans MEF++ :

1. ConstElem 2. P0IsoP1 3. P0IsoP2 4. Lin 5. P1IsoP1Bulle 6. P1IsoP2 7. P1IsoP2Bulle 8. P1NC 9. LinElem 10. P1 disc

11. P1 disc B 12. P1 disc C 13. Mini 14. Sommet-Face 15. Sommet-Face-

Element 16. Quad 17. QuadElem 18. QuadBulle 19. QuadBulleNC 20. Sommet-

Arete-Facex3

21. HermiteOrdre3Inc 22. HermiteOrdre3

Dans les champs éléments finis de MEF++, les 2 concepts (interpolation et nœud de calcul) sont intimement liés. C’est un choix qui a été fait au début de l’existence de MEF++. Pourquoi? Simplement parce que le nombre de fonctions de base sur un élément définit automatiquement le nombre de nœuds de

20


calcul. C’est donc pour assurer une cohérence que l’on retrouve dans les champs une association intime entre l’interpolation et les nœuds de calcul. De plus, puisque MEF++ est prévu pour offrir la possibilité de mélanges d’éléments dans un même maillage, il faut assurer une cohérence dans les interpolations choisies pour chacun des types d’élément. Il faut donc choisir une combinaison valide d’interpolation pour que l’interpolation entre les différents types d’éléments soit compatible.

Figure 19 Exemples de champs d'éléments finis

Figure 20 Champs d'éléments finis combinés à un champ de transformation géométrique

Voici un exemple de code MEF++ où l’on « ajoute » un champ scalaire quadratique à un maillage : ------------------------- Maillage lMail; ... //On crée un objet de type ChampScalQuad en lui passant le maillage //auquel on veut qu’il soit lié. C’est au moment de la création du //champ que s’enclenche toute une mécanique derrière qui « ajoute » des //degrés de liberté selon le nombre de sommets et d’arêtes du maillage ChampScalQuad lChampT(lMail); ... -------------------------

21


Il est à noter que nous avons un petit problème de nomenclature. Puisque les champs prévoient le cas où il y aurait un mélange de types d’éléments, il devient difficile de trouver un nom juste pour le type d’interpolation que nous avons sur chaque type d’élément. Par exemple, lorsque l’on parle d’un « ChampScalLin », on veut dire que l’utilisation de ce champ avec des éléments 1D générera 2 nœuds de calcul, pour un triangle cela sera 3 nœuds de calcul, pour les quadrilatères cela sera 4 nœuds de calcul etc. On a un nœud de calcul par sommet, ce qui donne un champ qui combine les interpolations L2, T3, Th4, P6, H8 ensemble. Le nom scientifique de ce champ pourrait être «ChampScalL2T3Th4P6H8» et non « ChampScalLin ». On pourrait aussi l’appeler « ChampScalUnNoeudParSommet ». On peut consulter la documentation de la classe pour connaître exactement le type d’interpolation utilisée pour chaque forme d’élément. Par exemple, pour un champ « ChampScalLin », on peut voir dans la documentation en ligne () que l’interpolation utilisée est celle donnée par la classe « FonctionsLagrangeLin » (« https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/ ») qui comporte les bases polynomiales suivantes pour chaque forme d’éléments :

Élément 1D, 2 noeuds:

Élément triangle, 3 noeuds:

Élément quad, 4 noeuds:

Élément tetra, 4 noeuds:

Élément prisme, 6 noeuds:

Élément hexa, 8 noeuds: Plus visuellement, voici une représentation des nœuds de calculs et leurs positions pour les champ dits « linéaires » pour chaque type d’élément :

Figure 21 Champ*Lin pour tous les types d’élément

Voici quelques autres champs fréquemment utilisés dans MEF++ :

22



Figure 22 Champ*ConstElem pour tous les types d’éléments

Figure 23 Champ*Quad pour tous les types d'éléments

Lorsque nous avons un problème à plusieurs variables, il faut choisir un type de champ (type d’interpolation) pour chaque inconnue. Pour un problème en mécanique des fluides, on doit choisir un champ scalaire pour la pression et un champ vectoriel pour la vitesse : on pourrait choisir « ChampScalLin » pour la pression et « ChampVect3DQuad » pour la vitesse. Dans MEF++, l’usager est libre de choisir ce qu’il veut comme combinaison de champs (et donc d’interpolation), car il n’existe pas de combinaison préétablie ou imposée. Le code permet justement de changer facilement le type d’interpolation d’une variable de problème pour étudier l’effet sur la solution. Voici quelques exemples de combinaisons :

23


Figure 24 Interpolations mixtes: Quad-Lin

Figure 25 Interpolations mixtes: QuadBulle-LinDiscontinu

3.10.3 Les champs analytiques Dans MEF++, il existe aussi la notion de champ analytique. Cette notion particulièrement intéressante veut simplement représenter une fonction. Il est donc possible de définir une fonction et de l’évaluer aux coordonnées de référence d’un élément. Contrairement aux champs géométriques et aux champs éléments finis, les champs analytiques n’ont ni de fonction d’interpolation ni de degré de liberté.

24


Figure 26 Champ analytique, lié à un champ géométrique

Lorsque l’on utilise un champ analytique dans un calcul, il doit au préalable être relié à un champ géométrique. Pourquoi? Simplement parce qu’il faut une coordonnée réelle pour évaluer un champ analytique et que c’est le champ de transformation géométrique qui peut fournir une coordonnée réelle à partir d’une coordonnée de référence dans un élément. Aussi, depuis la version 2.0 de MEF++, les champs analytiques peuvent utiliser un autre champ comme une variable de l’expression algébrique. Cet autre champ peut lui-même être un champ avec des DDLs.

3.10.4 Les lois de comportement Certains champs dans MEF++ représentent une loi de comportement de matériau. Ces lois de comportement nous donnent les valeurs de certaines propriétés d’un type de matériau. Ces valeurs pourront par la suite être utilisées dans une formulation variationnelle écrite indépendamment de la loi de comportement. Voici quelques exemples de lois de comportement disponibles dans MEF++ 2.0 : - Hookéen - Neo-Hookéen - Mooney Rivlin - Yeoh

3.10.5 Les champs définis par morceaux de géométrie Les champs définis par morceaux de géométrie étaient l’une des nouveautés de MEF++ v2.0. Ces champs spéciaux sont simplement des champs qui sont définis pour chaque portion ou région de la géométrie, c’est-à-dire qu’à chaque morceau d’une géométrie, on va associer un champ. On peut associer n’importe quel type de champ à un morceau de la géométrie. Autant un champ représentant une valeur constante, une expression algébrique ou encore un champ éléments finis.

25


Figure 27 Champ défini par morceaux de géométrie

Ce type de champ assez particulier peut notamment être utilisé dans la définition de propriétés de matériaux. On peut alors affecter à chaque portion de la géométrie un champ qui représente la propriété physique que l’on veut utiliser pour notre calcul.

3.10.6 Les champs avec un changement de repère Autre nouveauté dans MEF++ v2.0, les champs avec changement de repère permettent d’évaluer une valeur qui n’est pas scalaire (vectorielle ou tensorielle) et de lui faire subir un changement de repère évalué par un autre champ au même point. Donc, c’est une combinaison de 2 champs, dont l’un contient les valeurs à évaluer et l’autre le changement de repère associé. Le résultat retourné par l’interpolation de ce champ est donc la valeur du 1er champ après avoir été transformée par le changement de repère du 2e champ. Ce type de champ peut aussi être utile pour les calculs avec des matériaux demandant des changements de repères. C’est le cas notamment de toutes les quantités tensorielles : tenseurs de diffusion, de contraintes, etc.

Figure 28 Champ comportant un changement de repère

26


Dans l’exemple de la figure Figure 28, on peut voir que les 2 champs qui définissent le champ avec changement de repère sont des champs « continus ». Il faut faire attention ici au sens que prend le mot « continu » puisque les changements de repère sont souvent définis par morceaux de géométrie; il y a forcément une discontinuité à l’intersection entre les morceaux. Toutefois, le champ défini sur un morceau de la géométrie est continu, c’est-à-dire qu’il peut être évalué autant sur un élément que sur un sommet. Dans l’exemple, on a un champ représentant le tenseur d’élasticité d’un matériau auquel on associe un changement de repère cylindrique. À chaque fois qu’on évalue le champ « ChampTensO4SymChangRepere », on doit d’abord évaluer le champ « ChampSolideHookeenConstant » et ensuite le changement de repère « ChampTO2NSymACBCyl » et calculer le changement de repère du tenseur et ensuite envoyer le tenseur d’élasticité résultant. Tout ceci est fait automatiquement et l’utilisateur du champ « ChampTensO4SymChangRepere » ne fait que demander les évaluations du champ.

3.10.7 Les champs d’empilement Autre nouveauté de MEF++ v2.0, les champs d’empilement sont des champs qui ne sont qu’une combinaison de pointeurs vers d’autres champs, pour chaque composante du champ. On peut donc définir un champ vectoriel en 3 dimensions à partir de 3 champs scalaires qui représenteront respectivement les composantes X, Y et Z. De plus, on peut affecter au champ d’empilement le même champ à deux composantes différentes. Ceci peut être utile dans un champ composé d’expressions algébriques dont deux composantes sont identiques, afin d’optimiser les évaluations faites :

Figure 29 Champ d'empilement d'autres champs

Veuillez noter qu’il n’est pas possible de créer un champ d’empilement et de l’utiliser comme la variable inconnue d’un problème. L’utilisation de champ d’empilement est donc réservé pour construire une valeur vectorielle ou tensorielle qui sera utilisée dans un calcul comme une fonction donnée.

3.10.8 Les champs d’extension de peau Comme mentionné précédemment, ces chams ont été créées pour les besoins liés aux problèmes avec contact. Toutefois, ils peuvent aussi être utilisés dans n’importe quel type de problème. Donc donné un champ qui vit sur le domaine complet (UΩ) on a automatiquement la possibilité de l’interroger au bord du domaine (UΓ) s’il est un champ dit « continu ». On peut aussi évaluer le champ sur le maillage de peau (UΓp). Par extension, on a automatiquement la possibilité d’évaluer le champ sur le bord du maillage de peau (UΓ Γp), s’il est « continu ».

27


Figure 30 Champ d'extension de peau

Pour les champs qui sont discontinus (et même pour les champs continus) il existe une possibilité intéressante dans MEF++ : l’évaluation au bord d’un élément (vs l’évaluation sur l’élément de bord). Prenons un exemple. Dans un problème de mécanique des solides, les contraintes sont la plupart du temps discontinues et ne peuvent être évaluées que si l’on a un élément du domaine. Si on a un maillage de peau, pour pouvoir évaluer le champ, il faudra retrouver l’élément du domaine, associé à l’élément de peau. Ceci est possible grâce aux connectivités inverses :

Figure 31 Champ d’extension de peau : évaluation au bord de l'élément du domaine

Nous verrons plus loin qu’il y a aussi une astuce qui a été ajoutée pour optimiser ces calculs.

3.10.9 Les champs de coquille Voici un champ qui a été créé pour traiter des problèmes où il y a plusieurs physiques, mais surtout différents domaine où s’appliquent ces physiques. Il s’agit donc d’un champ qui permet de « voir » le champ qui est définit sur tout le domaine dans la partie restreinte qu’est la coquille. C'est-à-dire, qu’on veut interroger le champ UΩ sur la partie Ωc, donc on peut créer une surcouche sur le champ UΩ qui deviendra UΩc.

Figure 32 Champ de coquille

3.11 Relations Géométrie/Entités Géométriques/Maillage/Champ Il existe une relation entre les concepts de géométrie, d’entité géométrique, de maillage et de champ. D’abord, tout commence par la notion de géométrie. La géométrie définit la pièce que l’on veut représenter par des points, courbes, surfaces et volumes (« LieuGeometrique »).

28


Sur cette géométrie, on définit des entités géométriques comme étant des regroupements de lieux géométriques. C’est l’usager qui regroupe ces lieux géométriques pour qu’ils représentent un morceau particulier de la pièce ou de la région. En créant les entités géométriques, l’usager prépare ainsi les régions où il pourra imposer des conditions limites ou affecter des matériaux. Il y a ensuite le maillage. Un maillage n’est qu’UNE discrétisation d’une géométrie. Comme on l’a déjà vu, il peut exister plusieurs maillages pour une même géométrie. Le maillage qui est rattaché à une géométrie peut être utilisé pour faire un problème complet. Le maillage étant rattaché à une géométrie, cela identifie chacun de ses sommets, arêtes, faces et éléments à un lieu de la géométrie (« LieuGeometrique »). On ajoute ensuite la notion de transformation géométrique (« ChampGeometrique »). La transformation peut être linéaire ou quadratique. Le champ de transformation géométrique que l’on choisit d’associer à un maillage permettra de transformer les éléments réels vers l’élément de référence. Enfin, on ajoute au maillage les deux notions suivantes : soit la notion de nœud de calcul et la notion d’interpolation. Ces deux notions sont intimement liées entre elles et de plus, on les associe (également) au au champ de transformation géométrique. La notion d’interpolation permet de calculer les valeurs des fonctions de base, de leurs dérivées premières et secondes, avec et sans transformation sur l’élément réel. Avec des coordonnées de référence (données le plus souvent par le schéma d’intégration), les matrices jacobiennes de transformation de l’élément réel vers l’élément de référence (données par le champ géométrique) et un élément, on peut calculer les fonctions d’interpolation ainsi que leurs dérivées premières et secondes. Une fois les fonctions d’interpolation calculées, on peut s’en servir pour interpoler la valeur d’un champ sur un élément. Le schéma suivant représente ces différentes relations entre la géométrie, les entités géométriques, les champs géométriques, le maillage et les champs éléments finis :

Figure 33 Relations entre la géométrie, les entités, les maillages et les différents champs

Dans cette figure, les nœuds géométriques désignent les coordonnées des sommets et des milieux d’arêtes d’un maillage. Cela inclut donc les sommets donnés par le maillage comme les milieux d’arêtes donnés par le « ChampGeoQuad » par exemple.

29


3.12 Schéma d’intégration Qu’est-ce qu’un schéma d’intégration dans MEF++? Pour bien comprendre la réponse à cette question, il faut d’abord se souvenir que MEF++ a été prévu pour résoudre des problèmes dans lesquels il y aurait un mélange d’éléments (« élément » au sens géométrique, n’oubliez pas), c’est-à-dire que l’on peut mélanger des éléments 1D, 2D et 3D dans un même maillage. Pour cette raison, il a fallu inclure dans la notion de schéma d’intégration une association avec un type d’élément. Puisqu’il y a aussi la notion de face et d’arête dans le programme, il faut prévoir les points d’intégration qui seront utilisés par les intégrales de bord (condition aux limites de Neumann par exemple). Ainsi, un schéma d’intégration comprend les points d’intégration et les poids qui seront utilisés pour chaque type d’élément, les arêtes, les faces à 3 côtés et les faces à 4 côtés, ce qui fait un total de 9 types de points d’intégration à prévoir dans un schéma d’intégration. La réponse à « Qu’est-ce qu’un schéma d’intégration dans MEF++? » est donc : c’est une notion qui inclut un type de points d’intégration et de poids pour tous les types d’éléments, d’arêtes ou de faces que l’on peut rencontrer dans un maillage. De façon plus visuelle, on pourrait le voir de la façon suivante :

Figure 34 Les composantes d'un schéma d'intégration

Dans les schémas d’intégration, on peut aussi faire pré-calculer les différents schémas d’intégration dits « de bord » pour tous les types d’éléments, afin de permettre l’utilisation des champ d’extension de peau en mode « évaluation au bord de l’élément du domaine ». Par exemple, pour un schéma d’intégration sur les arêtes, il faudra créer 6 schémas de bords pour les triangles, soit 1 pour chaque arête, multiplié par 2 sens de parcours possible.

30


Figure 35 Schéma de bord

Les combinaisons augmentent rapidement pour les éléments 3D. Voici combien de schéma de bord sont créés par type d’éléments : triangle quad tétra prisme hexa total arête 6 8 12 18 24 68 Face 3 24 12 36 Face 4 24 48 72

3.13 Corps Depuis l’apparition des problèmes de contact, le notion de Corps a été introduite pour adresser un besoin d’échanger d’information entre différents maillages ou objets, que nous nommerons au sens large, des « Corps ». Un Corps peut être une définition complètement analytique d’un objet quelconque. Il peut aussi être un maillage, qui représente cet objet. Aujourd’hui, il existe 3 sortes de Corps :

– CorpsEF – CorpsGeoMail – CorpsGeoAna

Le plus intéressant est le CorpsEF, qui peut aller chercher de l’information sur ses corps voisins. C'est-à-dire qu’un CorpsEF va construire une liste de points ({x1}) pour lesquels il voudra interroger tous ses voisins (incluant lui-même). Chaque Corps voisin recevra donc une liste de point et tentera de trouver un correspondant sur lui-même. Il y a 2 « modes » pour trouver des correspondants, soit la projection orthogonale (Po) ou le prolongement de normale (Pn). Donné une réponse fructueuse, le corps interrogé conservera la position du correspondant (x2), la normale à ce point (n2) ainsi que la distance (d=|x1-x2|). Déjà le CorpsEF peut récupérer ces information à propos de la coordonnée du correspondant (x2=P(x1)), la normale à ce correspondant (n2) et la distance (d). De plus, il peut aussi demander la valeur d’un champ qui vit sur ce Corps interrogé, au point correspondant. Par exemple, si on veut connaître la température au point correspondant, le CorpsEF peut demander d’interpoler le champ « T » au point «x2=P(x1) », soit « T(p(x1)) » ou « T(x2) ». Ces valeurs, provenant « de l’extérieur », seront notées : « T_ext ». Voici schématiquement ce qui se passe :

31


Figure 36 Échange entre Corps

Un second type d’échange est aussi possible, soit la distribution de valeurs nodales. Pour cette opération, le CorpsEF envoie à ces voisins des valeurs (issues d’un assemblage) pour qu’eux le distribue sur les DDLs de l’élément dans lequel est le point correspondant. (#2 dans la Figure 36).

32


4. Formulation variationnelle et résolution d’un problème Dans le document d’introduction à la méthode des éléments finis (http://www.giref.ulaval.ca/coursmefpp), on a vu que le système global est obtenu à partir de la formulation variationnelle du problème aux limites. Ainsi, l’usager désirant développer une nouvelle application doit en premier lieu écrire la formulation variationnelle du problème. Par conséquent, la formulation variationnelle va permettre d’écrire la matrice et le résidu élémentaires. Cette tâche peut être complexe surtout si le problème comporte plusieurs inconnues, c’est-à-dire les problèmes couplés. Afin de simplifier l’écriture de la formulation du problème, MEF++ introduit le concept de terme de formulation (« TFormulation ») qui jouera un rôle essentiel par la suite. C’est à partir des termes de formulation que l’usager va développer son application.

4.1 Détails de la résolution d’un problème Nous voici rendus à décrire en détail la résolution d’un problème dans MEF++ : • Lecture des données d’entrée (les 5 fichiers typiques - .mail, .geom, .enti, .CL, .champs) • Affectation des champs et schéma d’intégration aux termes de formulation • Ajout des termes de formulation à l’objet « problème » • Assemblage et résolution du système global • Exportation des résultats

4.1.1 Lecture des données Cette étape consiste simplement à lire les données sur disque. Pour résoudre un problème, on devra avoir les données suivantes : • Géométrie ( fichier .geom, classe « Geometrie ») • Entités géométriques (fichier .enti, classe « ListEntitesGeometrique ») • Maillage (fichier .mail, classe « Maillage ») • Les champs pour chaque variable du problème (fichier .champs, classe « GestionFichierChamps ») • Liste de conditions aux limites (fichier .CL, classe « ListeConditionsLimites ») Une fois ces données en mémoire, nous sommes prêts à les utiliser.

4.1.2 Initialisation des termes de formulation Cette étape consiste à bien initialiser les termes de formulation utilisés lors du calcul. Il faut en effet affecter à tous les termes de formulation les champs dont ils devront se servir pour faire leurs calculs. De plus, c’est à cette étape que l’on affecte à un terme de formulation le schéma d’intégration à utiliser.

4.1.3 Ajout des termes de formulation à l’objet « problème » Cette étape consiste à « construire » le problème que l’on veut résoudre en choisissant les différents termes de formulation qui vont le composer. On ajoute simplement les termes de formulation initialisés à l’étape précédente à l’objet « problème » créé pour les contenir.

4.1.4 Assemblage et résolution du système global

33

http://www.giref.ulaval.ca/mefpp20_grandconcepts.ppt


Maintenant que nous avons un problème à résoudre, on peut demander à un solveur de l’utiliser pour faire l’assemblage de la matrice globale et du vecteur global et ensuite faire la résolution du système ainsi créé. Une fois résolu, nous avons la solution du problème pour nos différentes inconnues.

4.1.5 Exportation des résultats La dernière étape consiste simplement à exporter les résultats calculés pour la visualisation. L’exportation se fera selon le visualisateur désiré.

4.2 Concept de « problème » Qu’est-ce qu’un « problème » dans MEF++? Un problème est d’abord et avant tout un « conteneur » ou « liste » de termes de formulation. C’est en « ajoutant » les termes de formulation à un problème que vous créer votre propre problème. Depuis MEF++ v2.0, nous avons mis en place une mécanique complexe mais performante nous permettant d’avoir un concept de « problème » très puissant. Donc, il faut construire son problème complet à partir des morceaux que sont les termes de formulation. L’avantage d’utiliser la notion de problème telle que proposée ici est de bénéficier du développement dans les autres aspects du code que vous pourriez moins connaître, comme la résolution par exemple. En utilisant la classe problème pour construire votre problème, vous pouvez facilement utiliser différents schémas de résolution instationnaires par exemple. De plus, la structure de la classe « ProblemeEF » vous permet de lire les données d’entrée (géométrie, maillage, etc.) de façon usuelle et aussi d’écrire les résultats sur fichier sans rien avoir à coder.

Figure 37 Relations entre un problème et ses termes de formulation

D’un point de vue plus global, voici la relation entre les termes, le problème, les champs et le schéma d’intégration :

34


Figure 38 Relations entre un problème, les termes de formulation, les champs, les matériaux et les

schémas d'intégration

On peut voir à la Figure 38 qu’un problème a un lien vers les termes de formulation qu’il utilise. Ces mêmes termes ont un lien vers les champs (matériaux, inconnues, transformation géométrique) qu’ils utilisent ainsi qu’un schéma d’intégration. Une chose importante que fait aussi le problème, c’est l’assemblage de la matrice globale et du vecteur global. Puisque c’est le problème qui a la liste des termes de formulation, un lien vers le maillage, il lui est possible de faire la boucle sur les éléments et d’assembler la matrice et le vecteur. Voici un schéma de ce qui se passe :

Figure 39 Algorithme d'assemblage pour les problèmes

Lorsque l’on demande à un problème d’assembler le système global, il va faire plusieurs boucles : • Boucle sur les termes de formulation pour remettre à « zéro » les évaluations demandées dans les

champs • Boucle sur les termes de formulation pour ajouter les évaluations à faire dans les champs pour

l’assemblage demandé (matrice ou vecteur) • Boucle sur les éléments

• Boucle sur les termes de formulation • Transfert (calcul) des informations des champs et matériaux pour le calcul sur l’élément • Évaluation de l’intégrale au niveau élémentaire

• Boucle sur les points de Gauss

35


• Évaluation sur un point de Gauss

4.3 Terme de formulation Pour l’usager de MEF++ qui veut développer son application, « l’unité » de programmation est le terme de formulation. Un terme de formulation sera défini comme une partie de la formulation variationnelle. Un terme de formulation est naturellement associé à une partie de la matrice élémentaire ou du résidu élémentaire. Chaque morceau de la matrice élémentaire portera le nom de bloc élémentaire dont les propriétés seront encapsulées dans la classe « BlocMElem ». De même pour la classe « BlocVElem » qui sera associée à une partie du résidu élémentaire. C’est un concept très puissant et original de MEF++. Cet outil permet:

• de décomposer un problème complexe en petites unités faciles à coder; • de réutiliser facilement des termes de formulation existants; • de construire une application à partir d’un ensemble de termes de formulation; • de coder facilement un problème couplé; • de modifier le schéma d’intégration selon le terme de formulation, de manière à minimiser le temps de calcul. • de présenter une vision du code qui est proche de l’intégrale à évaluer

Dans ce qui suit, nous allons décrire les différentes étapes pour écrire un terme de formulation. En premier lieu, on doit se demander quelles seront les informations nécessaires pour coder un terme de formulation. Le document d’introduction à la méthode des éléments finis nous fournit la réponse. Lors de la boucle d’assemblage, on doit pouvoir extraire un ensemble d’informations relatives à l’élément courant.

1. Nous avons besoin de connaître tous les champs intervenant dans le calcul du système élémentaire. 2. Si le terme de formulation contribue à la matrice élémentaire, il faut préciser le couplage, c’est-à-dire la paire de champs, un en ligne (fonctions tests) et l’autre en colonne (fonctions de base), qui sert au calcul. Sinon, il faut tout de même identifier le champ en ligne (fonctions test). 3. On doit pré-évaluer les fonctions de base et leurs dérivées sur l’élément de référence. 4. On doit aussi évaluer les valeurs aux points de Gauss pour chacun des champs du terme de formulation ainsi que leurs dérivées en coordonnées réelles. 5. Finalement, on doit pouvoir évaluer le déterminant de la matrice jacobienne de la transformation géométrique reliant l’élément de référence à l’élément courant. À cela s’ajoute les poids et les coordonnées de la formule d’intégration numérique.

Ainsi, un terme de formulation dans MEF++ devra être capable d’obtenir aisément toutes ces informations. Si vous avez un problème de mécanique des solides, vous devrez écrire le terme de formulation qui le calcule. Il se peut toutefois que le terme de formulation dont vous avez besoin ait déjà été programmé par quelqu’un d’autre et qu’il soit disponible pour tous. Pour le savoir, il suffit de consulter la liste des termes

36


de formulation déjà disponibles (voir les classes commençant par « TF » https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/). Prenons par exemple un problème de diffusion thermique :

Après développement, cette formulation sera composée de 3 termes (sans les CL). Les calculs nécessaires pour assembler ce système pourraient être divisés en 2 termes de formulations (au sens MEF++) distincts. D’abord, un premier terme de formulation pourrait calculer le terme source séparément :

ensuite, un second terme de formulation pourrait calculer les contributions suivantes : Matrice:

Résidu:

Ce choix est tout à fait libre. Un usager pourrait décider de regrouper tous les calculs dans un seul terme de formulation, pour autant qu’il n’y ait qu’un seul couplage de la matrice qui soit impliqué. Si on regarde maintenant l’aspect programmation, dans MEF++, un TF est une classe qui dérive de la classe TFGenerique. Plus précisément, on a la hiérarchie suivante:

Figure 40 Hiérarchie des termes de formulation

Les trois classes de base encapsulent des fonctionnalités communes d’un terme de formulation défini par l’usager. Donnons quelques détails sur ces classes :

37



« VisiteurElementConst » Le rôle de cette classe est de retrouver le type de l’élément courant, celui qui est déclaré à la lecture du maillage. Le mécanisme de Visiteur est utilisé à cette fin d’où le nom de la classe. « TFormulation » Cette classe contient les méthodes d’assignation communes à tous les termes de formulation : asgnMaillage(...), asgnSchemaIntg(...),asgnChampGeometrique(...), etc. « TFGenerique » Cette classe dimensionne les tableaux élémentaires. Elle fournit une interface virtuelle qui permettra de créer un problème à partir de plusieurs termes de formulation. Les termes de formulation peuvent être écrits avec une approche matricielle comme tensorielle. Voici un exemple de terme de formulation de diffusion :

Figure 41 La composition d'un terme de formulation

4.3.1 Types de termes de formultaion À ce jour, il existe 4 types de termes de formulation, qui permetteront d’intégrer de différentes manière, ou du moins dans différents contextes.

Figure 42 Les 4 types de termes de fomulation

38


4.4 Rôles d’un terme de formulation Les termes de formulation ont des liens vers plusieurs autres objets qu’ils utilisent pour le calcul élémentaire. Tous les termes de formulation jouent donc un rôle important dans MEF++ pour le calcul élémentaire. Voici de façon schématique les liens d’un terme de formulation traitant un problème thermique :

Figure 43 Relations entre un terme de formulation, ses champs, ses matériaux et son schéma

d'intégration

Voici les différents rôles du terme de formulation : • « Ajouter » les couplages de l’équation; • « Ajouter » aux champs et aux matériaux qu’il utilise le schéma d’intégration qui sera utilisé pour le

calcul du terme de formulation; • « Ajouter » aux champs et aux matériaux les demandes d’évaluation qui seront nécessaires (valeur du

champ vs dérivée) selon les calculs demandés (matrice et/ou résidu); • Transférer l’information des champs sur un élément pour le calcul; • Faire l’intégration élémentaire de la matrice et du résidu. Un terme de formulation fait plusieurs choses en vue du calcul élémentaire. C’est lui qui « avertit » ou « ajoute » le schéma d’intégration aux différents champs (et matériaux) que le terme de formulation utilise. C’est lui qui demande aux champs (et matériaux) qu’il utilise de calculer leurs valeurs aux différents points du schéma d’intégration. C’est lui qui « avertit » ou « ajoute » les évaluations que devront faire les champs (et matériaux) pour le calcul demandé (matrice ou résidu). Finalement, c’est lui qui fait la boucle sur les points d’intégration et le calcul pour chacun d’eux, plaçant le résultat dans la matrice ou le vecteur élémentaire. Regardons en détail chacun de ces rôles.

4.4.1 Assignation des champs et d’un schéma d’intégration Typiquement, les termes de formulation sont instanciés (créés) dans les programmes principaux (« main »). Après leur instanciation, on doit leur assigner les champs et le schéma d’intégration qui serviront par la

39


suite à faire les calculs. Chaque terme de formulation a donc une méthode qui lui est propre et qui permet de faire ce travail. Le TF doit connaître tous les champs servant au calcul. Les différentes intégrales liées au calcul élémentaire seront évaluées numériquement. Pour cela, nous avons besoin de spécifier le schéma d’intégration qui sera utilisé. La méthode TF*::asgnChampsEtSchemaIntg(...) (ou semblable) est responsable de faire 3 tâches : 1- Conserver un lien vers les champs passés 2- Ajouter le schéma d’intégration aux champs passés 3- Ajouter le couplages entre les champs ligne et colonne Les termes de formulation conservent tous un pointeur vers chacun des champs qu’ils utilisent. Au départ ces pointeurs sont normalement mis à zéro, mais, lorsque la méthode d’assignation des champs est appelée, les attributs de la classe sont alors initialisés avec l’adresse des champs assignés. Le cas du terme de formulation de diffusion est illustré à la Figure 44.

Figure 44 Méthode TFDiffusion::asgnChamps(...)

Après avoir conservé le pointeur aux champs, le terme de formulation va ajouter le schéma d’intégration qui sera utilisé pour le calcul élémentaire à chacun de ses champs (champ de transformation géométrique, champ de calcul éléments finis, champ analytique, matériau). C’est une étape importante dans le processus de préparation à la résolution, puisque c’est à ce moment que l’on « prépare » les champs pour les calculs. Lorsque l’on ajoute le schéma d’intégration au champ, il se déroule 3 étapes. Au commencement, le champ ne contient aucun schéma d’intégration (Figure 45).

40


Figure 45 Le champ avant l’ajout d'un schéma d'intégration

Lorsque le terme de formulation appelle la méthode « .ajouteSchémaIntg(...) » sur le champ en lui passant le schéma d’intégration qui sera utilisé, le champ conserve le schéma d’intégration qui lui est passé dans une mémoire. Chaque schéma d’intégration est marqué d’un numéro unique. Ainsi, si l’on ajoute plusieurs fois le même schéma d’intégration au même champ, celui-ci détecte que c’est le même et ne le rajoute pas à sa mémoire. Chaque champ a donc une mémoire qui contient (entre autres) une copie du schéma d’intégration (Figure 46). Le contenu de cette mémoire sera détaillé un peu plus loin.

Figure 46 Ajout d'un schéma d'intégration à un champ : 1re étape

Certains champs, comme le « ChampGeoLin », « ChampScalLin », etc., sont associés à des fonctions d’interpolation et utilisent un objet contenant ces fonctions d’interpolation (d’autres, comme le champ analytique, ne contiennent pas de fonction d’interpolation). Dans le cas du « ChampGeoLin », c’est la classe « FonctionsLagrangeLin » qui est utilisée. Le champ de transformation géométrique va donc passer le schéma d’intégration à cet objet « FonctionsLagrangeLin » pour qu’il puisse lui aussi le conserver dans une mémoire (Figure 47).

41


Figure 47 Ajout d'un schéma d'intégration à un champ : 2e étape

Au moment où l’objet contenant les fonctions d’interpolation reçoit le schéma d’intégration, il fait une pré-évaluation des fonctions de base, de leurs dérivées premières et secondes (sur l’élément de référence) si cela est possible (Figure 48).

Figure 48 Ajout d'un schéma d'intégration à un champ : 3e étape

L’idée générale à retenir de cet ajout du schéma d’intégration est que tous les champs et fonctions d’interpolation utilisés par le terme de formulation contiennent maintenant une copie du schéma d’intégration dans une mémoire. Dans cette mémoire, on retrouvera, non seulement le schéma d’intégration, mais aussi les résultats des évaluations du champ ou des fonctions de base pour un élément donné. C’est cette « mémoire » que les champs et fonctions de base vont utiliser pour se « souvenir » de la dernière évaluation demandée pour chaque schéma d’intégration ajouté. Donc, lorsqu’un calcul a déjà été fait sur un élément, cette mémoire va simplement retourner la réponse déjà calculée si l’on repose la même question (sur le même élément). La mémoire se souvient donc du dernier élément évalué, du schéma d’intégration utilisé et, bien sûr, des résultats du calcul.

4.4.2 Couplage

42


Si le terme de formulation contribue à la matrice élémentaire, il faut préciser le couplage, c’est-à-dire la paire de champs, un en ligne (fonctions tests) et l’autre en colonne (les DDLs) qui sert au calcul. Sinon, il faut tout de même identifier le champ en ligne (fonctions tests). Un TF peut contribuer à la matrice élémentaire ou au résidu élémentaire. 1. Matrice élémentaire: Si le TF contribue à la matrice élémentaire, on précisera le couplage grâce à la méthode : void TFGenerique::asgnCouplage(const Champ& pChampFctTestsLigne, const Champ& pChampDDLColonne, bool pIndiceSymetrie = false) La variable optionnelle « pIndiceSymetrie » est utile lorsque la matrice élémentaire (pour l’ensemble des TF du problème) comporte deux blocs symétriques. L’indice égal à "true" permet d’assembler un seul de ces deux blocs. Le problème de Stokes fournit un exemple d’utilisation de cette option. 2. Résidu élémentaire: Si le TF contribue seulement au résidu élémentaire, on précisera uniquement le champ en ligne grâce à la méthode void asgnChampLigne (const Champ& pChampFctTestsLigne); Cette opération se retrouve habituellement dans la méthode « TF*::asgnChampsEtSchemaIntg(...) ».

4.4.3 Méthode : TF*::ajouteEvaluationsAFaire(…) Après avoir ajouté aux champs les schémas d’intégration qui seront utilisés, chaque terme de formulation est maintenant prêt à demander des évaluations à ces champs. Pour un terme de formulation donné, on connaît les évaluations à faire pour chaque champ, selon que l’on assemble la matrice ou le vecteur élémentaire. Ainsi, chaque terme de formulation peut ajouter à chacun de ses champs les évaluations à faire pour un schéma d’intégration en particulier. L’ajout des évaluations à faire est réalisé avant la boucle d’assemblage sur les éléments. Elle a pour but de recueillir toutes les évaluations demandées à chaque champ, et ce, pour chacun des schémas d’intégration ajoutés au préalable. La première chose à faire dans la méthode « TF*::ajouteEvaluationAFaire(bool pAssembleMatrice, bool pAssembleResidu) » de votre classe, est de recueillir, pour chacun des champs, les évaluations à faire selon que l’on assemble la matrice ou le vecteur élémentaire. Pour ce faire, il existe une petite classe qui s’appelle « EvalsChampLocal » (Figure 49) qui donne le « menu » des choix qu’il est possible de faire. En utilisant les entrées de ce menu, on peut activer les évaluations qui seront demandées pour un champ et un schéma d’intégration donné.

43


Figure 49 La classe «EvalsChampLocal» qui sert de « menu »

Une fois que l’on a « coché » les évaluations que l’on veut pour un champ, on peut ajouter les demandes d’évaluation pour ce champ en appelant la méthode « ::ajouteEvaluationsAFaire(Entier pEvaluation, SchemaIntg& pSchema) » (Figure 50). Il faut noter que, pour les champs de transformation géométrique, il existe 2 méthodes différentes. Il y a une méthode « ::ajouteEvaluationsTransformationAFaire(Entier pEvaluation, SchemaIntg& pSchema) » qui sert à faire les calculs de la matrice jacobienne en chaque point de Gauss et une méthode « ::ajouteEvaluationsAFaire(Entier pEvaluation, SchemaIntg& pSchema) » qui sert à évaluer le champ lui-même, étant donné les points de Gauss. Dans le cas d’un champ de transformation géométrique, l’évaluation de ce dernier en des coordonnées de référence et un élément donné revient à calculer la position réelle de cette coordonnée de référence.

Figure 50 Ajout des évaluations demandées dans un « ChampGeoLin »

Cette opération d’ajout des évaluations demandées se fait aussi sur les objets contenant les fonctions de base associées aux champs qui sont présentes dans les couplages (Figure 51).

44


Figure 51 Ajout des évaluations demandées dans un objet « FonctionsLagrangeLin »

En plus du champ de transformation géométrique et des fonctions d’interpolation, on peut aussi ajouter au champ représentant une variable (ex. : le champ scalaire qui représente la température) les évaluations à faire :

Figure 52 Ajout des évaluations demandées dans un « ChampScalQuad »

L’avantage d’utiliser ce concept d’ajout des évaluations à faire sur chaque champ se traduit par une optimisation des calculs à faire si plusieurs termes de formulation utilisent le même champ avec un même schéma d’intégration. À ce moment, on fait un « OU » logique avec les évaluations demandées et les résultats futurs seront stockés dans une mémoire du champ, associée au schéma d’intégration (Figure 53).

45


Figure 53 Ajout des évaluations demandées par 2 termes de formulation dans le même champ

4.4.4 Types d’informations locales Vous savez maintenant que MEF++ est prévu pour traiter n’importe quel type d’élément. Toutes les classes nécessaires au calcul par éléments finis ont été prévues à cette fin. Toutefois, lorsque vient le temps d’effectuer un calcul concret, on le fait sur un type d’élément précis. Puisque les champs contiennent l’information sur chaque type d’élément possible, il faut leur demander de transférer l’information pour un élément d’un type connu. Ce passage de l’information contenue à un niveau « global » vers un niveau « local » se fait via 3 types de conteneurs d’informations locales : 1. Informations locales de transformation géométrique 2. Informations locales des fonctions d’interpolation 3. Informations locales du champ lui-même (valeurs du champ)

4.4.4.1 InfoLocalesTransformation Le premier type d’informations locales est celui concernant les transformations géométriques d’un élément. Étant donné un champ de transformation géométrique, on peut calculer les matrices jacobiennes de transformation de l’élément réel vers l’élément de référence pour chaque point de Gauss associé à l’élément passé pour le calcul (Figure 54). La classe « InfoLocalesTransformation » contient donc les informations locales de transformation géométrique pour un point de Gauss d’un élément. Lorsque l’on transfère les informations du champ « global » vers l’élément « local », on aura alors un vecteur contenant autant d’objets « InfoLocalesTransformation » qu’il y a des points de Gauss prévus pour cet élément.

46


Figure 54 Composition de la classe d'informations locales de transformation géométrique

On conserve aussi le produit du déterminant de la matrice jacobienne et du poids du point de Gauss associé. Notez que l’information de transformation géométrique est nécessaire pour d’autres calculs sur le même point de Gauss, notamment la transformation des dérivées premières et secondes des fonctions de base.

4.4.4.2 InfoLocalesInterpolation Le deuxième type d’informations locales concerne les informations liées aux fonctions d’interpolation d’un élément. Étant donné des fonctions d’interpolation « globales » (c’est-à-dire définies pour tous les types d’éléments), des informations de transformation géométrique et un élément donné, la classe de fonctions d’interpolation pourra calculer les fonctions de base (qui peuvent dépendre de l’élément réél), leurs dérivées premières et secondes transformées (sur l’élément réel). Ces évaluations sont conservées dans la classe « InfoLocalesInterpolation » (Figure 55) pour chaque point de Gauss d’un élément donné.

Figure 55 Composition de la classe d'informations locales d'interpolation

On y retrouve aussi les dérivées des fonctions d’interpolation sur l’élément de référence. Pour les fonctions de Lagrange, ces valeurs ne sont calculées qu’une seule fois et elles sont toujours présentes dans les informations locales d’interpolation.

47


4.4.4.3 InfoLocalesChamp Finalement, le troisième type d’informations locales concerne les informations locales à l’évaluation d’un champ. On y retrouve donc l’évaluation de la valeur du champ lui-même, c’est-à-dire la variable qu’il représente, les dérivées premières et secondes de cette variable autant sur l’élément de référence que sur l’élément réel. Cette variable peut être de type scalaire, vectorielle (2D ou 3D), tensorielle (2e ou 4e ordre) (Figure 56).

Figure 56 Composition de la classe d'informations locales d'un champ

Ces quantités sont conservées dans la classe Template « InfoLocalesChamp<PTTypeValeur> ». Il faut porter une attention particulière au paramètre PTTypeValeur de la classe.

4.4.5 Méthode : TF*::transfertInformationPourCalculSurElement(…) Maintenant que vous connaissez les 3 types d’informations locales possibles dans MEF++, il vous reste à voir le mécanisme de transfert de l’information contenue dans les champs et fonctions d’interpolation vers un élément. Ce transfert d’information « globale » vers les informations locales est fait par l’une des 3 méthodes suivantes, selon le type d’information désirée : 1. ChampGeometrique::transfertTransformationSurElement(Element&

pElement, SchemaIntg& pSchema) 2. FonctionsLagrange::transfertInterpolationSurElement(Element&

pElement, SchemaIntg& pSchema, VectDyn<InfoLocalesTransformation>& pVectInfoTransformation)

3. Champ*::transfertChampSurElement(Element& pElement, SchemaIntg& pSchema, VectDyn<InfoLocalesTransformation>& pVectInfoTransformation)

Lorsque le terme de formulation demande à son champ géométrique de transférer l’information de transformation géométrique pour un élément et un schéma d’intégration donné (Figure 57, étape 1), celui-ci consulte sa mémoire et fait les calculs pour cet élément si ceux-ci n’ont pas déjà été faits et conserve le résultat de ces calculs dans sa mémoire, sous forme d’informations locales de transformation (Figure 57, étape 2). Ensuite, le terme de formulation conserve un pointeur vers le vecteur d’informations locales de transformation pour les utiliser plus tard, dans le calcul élémentaire (Figure 57, étape 3).

48


Figure 57 Les 3 étapes d'un transfert d'informations globales à locales d'un « ChampGeoLin »

Ensuite, le terme de formulation demande à chacun de ses objets de fonction d’interpolation de transférer l’information d’interpolation pour un élément et un schéma d’intégration donné (Figure 58, étape 1), celui-ci consulte sa mémoire et fait les calculs demandés pour cet élément si ceux-ci n’ont pas déjà été faits et conserve le résultat de ces calculs dans sa mémoire sous forme d’informations locales d’interpolation (Figure 58, étape 2). Ensuite, le terme de formulation conserve un pointeur vers le vecteur d’informations locales d’interpolation pour les utiliser plus tard dans le calcul élémentaire (Figure 58, étape 3).

Figure 58 Les 3 étapes d'un transfert d'informations globales à locales d'un

«FonctionsLagrangeLin»

De même, le terme de formulation demande à chacun de ses champs de transférer l’information du champ pour un élément et un schéma d’intégration donnés (Figure 59, étape 1), celui-ci consulte sa mémoire et fait les calculs demandés pour cet élément si ceux-ci n’ont pas déjà été faits et conserve le résultat de ces calculs dans sa mémoire sous forme d’informations locales de champ (Figure 59, étape 2). Ensuite, le terme de formulation conserve un pointeur vers le vecteur d’informations locales du champ pour les utiliser plus tard, dans le calcul élémentaire (Figure 59, étape 3).

49


Figure 59 Les 3 étapes d'un transfert d'informations globales à locales d'un « ChampScalQuad »

4.4.6 Méthode TF*:: evalueIntegrale (...) C’est dans cette méthode que l’on fera la boucle sur les points de Gauss, que l’on fera le calcul d’une partie de la matrice élémentaire elle-même. Dans cette méthode, on utilisera toutes les informations transférées précédemment. Il y a deux paramètres de passés à cette méthode : TF*::evalueIntegrale (BlocMElem& pBlocMElemRigidite, BlocVElem& pBlocVElemResidu) Le bloc matriciel élémentaire et le bloc vectoriel élémentaire. Le bloc matriciel élémentaire « BlocMElem » représente donc une partie de la matrice élémentaire complète de la formulation. Le bloc vectoriel élémentaire « BlocVElem » représente quant à lui une partie du résidu élémentaire de la formulation. Le terme de formulation est responsable de remplir ces blocs avec la bonne information. Deux indices de type booléen permettent de contrôler les phases d’assemblage de la matrice ou du résidu. void asgnAssembleMatrice ( bool pAssembleMatrice); void asgnAssembleResidu ( bool pAssembleResidu); bool reqAssembleMatrice (); bool reqAssembleResidu (); On utilisera les 2 méthodes de requête dans l’assemblage élémentaire pour savoir s’il faut assembler la matrice ou le vecteur élémentaire.

4.5 Hiérarchie de champs Pourquoi une hiérarchie de champs? Simplement pour pouvoir changer le type d’interpolation utilisée dans un terme de formulation sans avoir à réécrire celui-ci. La hiérarchie des champs vous permet en effet de changer le type de champ (et donc d’interpolation) utilisé par un terme de formulation. Par exemple, si votre terme de formulation est prévu, pour recevoir un champ scalaire sans toutefois spécifier le degré d’interpolation, vous pourrez alors changer à votre guise le type d’interpolation et regarder le coût des

50


calculs, la qualité des résultats, etc. La possibilité de changer facilement d’interpolation est un avantage de la programmation orientée objets de MEF++. La hiérarchie des champs est assez développée. Si l’on regarde le haut de la hiérarchie, voici ce que l’on retrouve :

Figure 60 Tête de la hiérarchie des champs

On retrouve à la tête la classe ou concept de « Champ » très général. Immédiatement sous la classe « Champ », il y a 6 enfants. Chacun de ces enfants spécifie simplement le type de valeur que porte le champ. Par exemple, un « ChampScalaire » portera un nombre réel par nœud de calcul, alors qu’un « ChampVectoriel3D » portera 3 nombres réels (sous forme de « Vecteur3D ») par nœud de calcul.

Figure 61 Aperçu de la hiérarchie des champs scalaires

Ici, on peut voir qu’il y a 2 types de « ChampScalaire » : - Les champs scalaires continus (« ChampScalContinu ») - Les champs scalaires discontinus par élément (« ChampScalDiscParElement ») La différence majeure entre ces types de champ est le fait que les champs discontinus par élément ont leurs degrés de liberté qui ne sont pas communs aux éléments voisins. Toutefois, l’interpolation utilisée dans les 2 types de champ peut être la même (ex. : interpolation « linéaire » ou « L2T3Q4Th4P6H8 »).

51


Pour les champs scalaires continus, comme pour les discontinus, il y a plusieurs héritiers. Chacun de ces héritiers possède des interpolations plus ou moins riches. Pour plus d’information, consultez directement la hiérarchie sur WEB++ : https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/ .

Figure 62 Hiérarchie des champs scalaires continus

La dernière figure présente les différents enfants, à ce jour, de la classe « ChampScalContinu » qui sont disponibles. Veuillez noter la classe « ChampAnalytique » à droite. Comme on l’a vu à la page 24, les champs analytiques permettent d’utiliser une fonction algébrique comme un champ. Ce « ChampAnalytique » peut donc être utilisé lors d’un calcul pour extraire la valeur de la fonction en une coordonnée x, y, z donnée. La notion de « ChampAnalytique » est largement utilisée dans les conditions aux limites.

Figure 63 Hiérarchie complète des champs scalaires

52



On peut voir ici une vue d’ensemble de tous les héritiers de « ChampScalaire ». Notez qu’il apparaît ici un nouveau concept de champ : les champs distribués sur une géométrie (« ChampContinuSurGeometrie » et « ChampDiscontinuSurGeometrie »).

4.6 Pré/Post-traitement Pour plusieurs problèmes, il existe des calculs à faire avant et après chaque résolution, ou même avant et après chaque itération de Newton. On parle ici de pré-traitement et de post-traitement. Par exemple, dans certains problèmes de mécanique des solides, il faut faire la mise à jour des propriétés de matériaux. Cette mise à jour peut être faite plus ou moins souvent, au goût de l’usager. Les pré/post-traitements à effectuer sont spécifiques pour un problème donné. C’est donc la classe de « ProblemeEF » qui contiendra la liste des PPs (pré/post-traitements). Par exemple, si l’on veut calculer la valeur de la solution à un point de contrôle précis après une résolution, on pourra accomplir cette tâche avec un PP. Pour une liste des PPs disponible, on peut aller consulter le lien suivant : https://interne.giref.ulaval.ca/mefpp/code_docu/MEFPP_doxygen/, sélection la classe de base « PPTraitementGen » et regarder tous les héritiers. Voici quelques exemples :

- PPNormeL2 - PPReinterpole - PPResolutionProbleme - PPEvalueChampXYZ<PTTypeChamp>

Figure 64 Listes de PPs dans un ProblemeEF

Le problème conserve 4 listes de PPs qui seront appelés à différents moments par le solveur. Ces 4 listes sont : 1- Liste des pré-traitements (à un pas de temps) 2- Liste des post-traitements (à un pas de temps) 3- Liste des pré-traitements à une itération de Newton 4- Liste des post-traitements à une itération de Newton Lorsqu’un solveur résoud un problème, il n’a aucune connaissance des PPs précis qui sont utilisés. Tout ce que le solveur fait, c’est demander au problème d’effectuer le calcul pour une liste de PP en particulier.

53



Figure 65 Appels aux PPs par le SolveurNlinPETSc

4.6.1 PPResolutionProbleme Il existe un PP particulièrement intéressant qui se nomme « PPResolutionProbleme ». Ce PP sert à faire lancer la résolution d’un problème, à l’aide d’un solveur. Il peut donc résoudre un problème particulier avant ou après la résolution d’un premier problème. Par exemple, en mécanique des fluides, il est intéressant de calculer les lignes de courant. Pour ce faire, il faut faire la résolution d’un second système, une fois le problème d’écoulement résolu. Le second système utilise les données du premier pour se résoudre. Il s’agit donc de déclarer un second « ProblemeEF » dans le programme principal, ainsi qu’un solveur pour ce second problème et d’assigner le tout à un objet de la classe « PPResolutionProbleme » qu’on ajoute ensuite à notre problème de mécanique des fluides.

Figure 66 PPResolutionProbleme permet la résolution d'un second problème

54

mef++ v4.0: les grands concepts - accueil - giref · · 2017-02-15mef++ v4.0 : les grands...

Documents