Maillage et Visualisation Université Pierre et Marie Curie

Les trois projets
—–
Maillage et Visualisation
Université Pierre et Marie Curie
P. Frey, F. Hecht
EPU 3 / session 2006/2007
Table des matières
1
Sujet 1 : Algorithme de Maillage de Delaunay
1.1 Méthode optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Structure de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 À faire pour le projet 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
2
2
3
2
Sujet 2 : Interpolation de solution
2.1 À faire pour le projet 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3
3
Sujet 3 : Visualisation d’un maillage et d’une solution associée
3.1 À faire pour le projet 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
4
Introduction
Pour tout projet , il faut faire un document d’une dizaine de pages (sans les sources des programmes, ni
les dessins). Il faut bien sur présenter les phases d’analyse algorithmique, de validation, et d’exploitation.
Le projet est a rendre avant le dimanche 21 janvier à 24h par courriel aux
adresses : [email protected] et [email protected]
1
Sujet 1 : Algorithme de Maillage de Delaunay
But : générer la triangulation de Delaunay d’un ensemble de Np points de [0, 1]2 tirer aléatoirement
Voilà l’algorithme insertion des points
1
Projet Maillage et Visualisation
2
1. Générer un maillage formé d’un triangle (ou rectangle), qui contiendra tous les
points du futur maillage.
Algorithme 1
2. Ajouter les points Np un à un suivant un ordre aléatoire.
Les points ajoutés sont toujours dans un ou deux triangles. Trouvez ces triangles
en utilisant l’algorithme de localisation 2 et puis découpez le triangle en 3 triangle ou le quadrangle en 4 triangles.
3. Pour rendre le maillage de Delaunay, il suffit d’appliquer la méthode optimisation du maillage autour du point xk en rendant de Delaunay toutes les motifs
formés de 2 triangles contenant le point xk , et cela pour tous les points xk du
maillage juste après son insertion.
F IG . 1 – Répresentation graphique de l’algorithme 1, où tous les points sont mis dans un rectangle.
1.1
Méthode optimisation
b
b
2
1
a
2
1
a
F IG . 2 – Échange de diagonale d’un quadrilatère convexe selon le critère de la boule vide.
Nous ferons un échange de diagonale [sa , sb ] dans un quadrilatère convexe de sommets s1 , sa , s2 , sb (tournant dans le sens trigonométrique) si le critère de la boule vide n’est pas vérifié, comme dans la figure
2.
Le critère de la boule vide dans un quadrilatère convexe s1 , sa , s2 , sb en [s1 , s2 ] est équivalent à l’inégalité
angulaire (propriété des angles inscrits dans un cercle) :
s\
1 sa sb < s\
1 s2 sb
ce qui équivaut au critère d’échange de diagonale optimisé
→ −−→
−−→ −−→
→ −−→
−−→ −−→
det(−
s−
> det(−
s−
2 s1 , s2 sb ) (sa s1 , sa sb )
a s1 , sa sb ) (s2 s1 , s2 sb ),
(1)
Projet Maillage et Visualisation
3
où (., .) est le produit scalaire de IR2 .
1.2
Structure de données
Nous allons prendre une structure orientée sommet. C’est-à-dire que chaque sommet aura la double liste
des sommets connectés tournant dans le sens direct. Les triangles ne seront connus que virtuellement.
Je vous conseille d’utiliser la STL pour écrire ce logiciel.
Nous avons besoin d’un algorithme de localisation pour trouver le triangle virtuel qui contient un point.
Il faut quelque peut changer l’algorithme de promenade du cours car nous n’avons pas de triangles mais
seulement des sommets connectés.
Algorithme 2
1.3
Partant d’un sommet s, trouver les 2 sommets concécutifs (s, a) et (s, b) du sommet s
(où a et b sont les 2 autres sommets des arêtes), tournant dans le sens trigonométrique,
telles que les aires signées des 2 triangles A = aire(a, p, s) et B = aire(b, s, p) soient
positives.
Soit C = aire(a, b, s) l’aire signé du triangle . Si C ≥ 0 et C − A − B ≥ 0 alors le point
p dans le triangle s, a, b sinon choisir aléatoirement le nouveau point s entre les points
a et b et continuer.
À faire pour le projet 1
Programmez l’algorithme 1 . Faite une étude de la complexité des algorithmes, et une vérification numérique de la complexité. Une option de visualisation pas à pas pour comprendre de déroulement du programme est impérative avec gnuplot.
Pour finir, il faut écrire un fichier maillage au format .msh, pour que freefem++ puisse le lire.
2
Sujet 2 : Interpolation de solution
Le but est d’écrire une programme qui interpole une solution élément fini P1 Lagrange définie sur un
maillage convexe, sur un autre maillage du même domaine convexe.
Pour faire cela, vous aurez à écrire l’algorithme de recherche d’un triangle K dans un maillage convexe
Th contenant un point (x, y) suivant :
Algorithme 3
2.1
Partant du triangle K,
Pour les 3 arêtes (ai , bi ), i = 0, 1, 2 du triangle K, tournant dans le sens trigonométrique, calculer l’aire des 3 triangles (ai , bi , p). Si les trois aires sont positives alors
p ∈ K (stop), sinon nous choisirons comme nouveau triangle K l’un des triangles
adjacents à l’une des arête associée à une aire négative (les ambiguïtés sont levées
aléatoirement).
À faire pour le projet 2
1. Construire une classe maillage formée d’un tableau de sommets et d’un tableau de triangles, qui lit le
fichier maillage.
2. Construire une méthode dans la classe maillage donnant le triangle K 0 adjacent d’un triangle K opposé
à son sommet i ∈ {0, 1, 2}. La complexité de cette fonction doit être constante après bien sur une
unique initialisation en O(nT ) ou O(nT log2 (nT )).
Pour cela vous pourrez utiliser le chapitre chaîne et chaînage.
3. Programmez l’algorithme 3 en partant d’un triangle quelconque (ajoutez une nouvelle méthode de la
classe maillage).
Projet Maillage et Visualisation
4
4. Puis trouver pour chaque sommet de autre maillage le triangle le contenant. Afin de briser la complexité algorithmique, il faut utiliser l’assertion suivante : les sommets d’un même triangle sont proche
car les triangles sont petits.
Voila le code freefem++ pour générer un maillage d’un disque avec 50 points sur le cercle.
int n=50 ;
border a(t=0,2*pi){ x=cos(t) ; y=sin(t) ;label=1 ;}
mesh Th= buildmesh(a(n)) ;
savemesh(Th,"c"+n+".msh")
3
Sujet 3 : Visualisation d’un maillage et d’une solution associée
Le but de ce projet de visualiser une fonction f du carré ] − 1, 1[2 à valeur dans IR avec une précision de
ε donnée.
Il faut donc construire un maillage telle que l’erreur sur chaque arête du maillage soit inférieure à ε.
L’algorithme de raffinement de maillage est très simple : il consiste à couper les arêtes avec une erreur
trop importante en deux parties égales, et à couper ces triangles adjacents en 2 triangles
Si l’on utilise cette technique bêtement, la qualité des triangles devient vite très médiocre. Pour éviter ce
problème, il suffit de découper les arêtes en allant de la plus grande à la plus petite longueur. Pour cela on
utilisera une queue prioritaire (conteneur piriority_queue de la STL ) avec comme relation d’ordre la
longueur de l’arête.
Donc l’algorithme est :
1. insérer les arêtes à découpe dans la queue prioritaire
2. tant que la queue n’est pas vide faire :
(a) Prendre le sommet de la queue et découper les triangles adjacents et ajouter à la queue les arêtes
qui ont une erreur trop grande parmi les 2 nouvelles arêtes créées.
L’erreur sur une arête sera définie par :
e(A, B) ' max eα (A, B)
α∈A
avec eα (A, B) = |α( f (A) + (1 − α) f (B) − f (αA + (1 − α)B)| .
L’ensemble A peut être par exemple { 12 } , { 13 , 23 } ou { 14 , 4,2 , 44 } , ... suivant les cas.
3.1
À faire pour le projet 3
Programmer l’algorithme precédent pour visualiser les fonctions
f1 (x, y) = x2 + y2
f2 (x, y) = x2 + y3 + tanh(5sin(2(y + x))
avec la bibliothèque GLUT où le paramètre ε peut être changé interactivement, et bien sur il doit être
possible d’afficher ou non le maillage.
Vous pourrez utiliser le conteneur map de la STL avec une structure d’arêtes comme suit :
vector<Edge> E ;
//
votre tableau d’arêtes
Projet Maillage et Visualisation
map< pair<int,int>,int> VO ;
5
//
//
vector<R2>
P;
le numéro k du sommet opposé à l’arête orientée
//
si l’arête orientée est i,j alors
le triangle (i,j,k) tourne dans le sens direct
//
votre tableau des coordonné des sommets
Après avoir défini un classe Edge qui modélise une arête
class Edge : pair<int,int>
{ publc:
double l ;
....
Edge (const vector<R2> & P, int i, int j)
:pair<int,int>(i<j ? i : j ,
i<j ? j : i )
{
...
}
...
};
//
la longueur de l’arête
Voilà par exemple de code qui génère une maillage initial avec deux triangles du carré ] − 1, 1[2 .
NbT=2 ;
P.push_back(R2(-1,-1)) ;
P.push_back(R2(1,-1)) ;
P.push_back(R2(1,1)) ;
P.push_back(R2(-1,1)) ;
E.push_back(Edge(P,0,1)) ;
E.push_back(Edge(P,1,2)) ;
E.push_back(Edge(P,2,3)) ;
E.push_back(Edge(P,3,0)) ;
E.push_back(Edge(P,0,2)) ;
//
sommet 0
//
sommet 3
//
arête 0
//
arête 4
//
Les sommet opposées aux arêtes
il y a 6 ARETES car l’arête (0,2) est interne et vue dans le 2 sens
//
attention ici les arêtes sont orientées
VO[make_pair(0,1)]=2 ;
VO[make_pair(1,2)]=0 ;
VO[make_pair(2,3)]=0 ;
VO[make_pair(3,0)]=2 ;
VO[make_pair(2,0)]=1 ; //
arête interne, le triangle (2 0 1) tourne de le sens direct
VO[make_pair(0,2)]=3 ; //
arête interne, le triangle 0 2 3) tourne de le sens direct
//