TRUST 1.9.8
HPC thermohydraulic platform
Loading...
Searching...
No Matches
Tetraedriser_homogene_compact.cpp
1/****************************************************************************
2* Copyright (c) 2023, CEA
3* All rights reserved.
4*
5* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
6* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
7* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
8* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
9*
10* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
11* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
12* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13*
14*****************************************************************************/
15
16#include <Tetraedriser_homogene_compact.h>
17
18Implemente_instanciable(Tetraedriser_homogene_compact, "Tetraedriser_homogene_compact", Triangulation_base);
19// XD tetraedriser_homogene_compact tetraedriser tetraedriser_homogene_compact INHERITS_BRACE This new discretization
20// XD_CONT generates tetrahedral elements from cartesian or non-cartesian hexahedral elements. The process cut each
21// XD_CONT hexahedral in 6 pyramids, each of them being cut then in 4 tetrahedral. So, in comparison with
22// XD_CONT tetra_homogene, less elements (*24 instead of*40) with more homogeneous volumes are generated. Moreover, this
23// XD_CONT process is done in a faster way. Initial block is divided in 24 tetrahedra:
24// XD_CONT \includeimage{{tetraedriserhomogenecompact.jpeg}}
25
26
27Sortie& Tetraedriser_homogene_compact::printOn(Sortie& os) const { return Interprete::printOn(os); }
28
29Entree& Tetraedriser_homogene_compact::readOn(Entree& is) { return Interprete::readOn(is); }
30
31// Traitement des faces
32void Tetraedriser_homogene_compact::decoupe(Domaine& domaine, Faces& faces, IntTab& new_soms_old_elems, IntTab& fait_sommet, int nface) const
33{
34 IntTab& sommets = faces.les_sommets();
35 int nb_faces = sommets.dimension(0);
36 assert(sommets.dimension(1) == 4);
37 IntTab nouveaux(4 * nb_faces, 3);
38 faces.voisins().resize(4 * nb_faces, 2);
39 faces.voisins() = -1;
40 IntVect indice(5);
41
42 for (int i = 0; i < nb_faces; i++)
43 {
44 indice(0) = sommets(i, 0);
45 indice(1) = sommets(i, 1);
46 indice(2) = sommets(i, 2);
47 indice(3) = sommets(i, 3);
48
49 int i0 = indice(0);
50 int i1 = indice(1);
51 int i2 = indice(2);
52 int i3 = indice(3);
53 int i4 = -1;
54
55 // on remet un peu d'ordre dans les indices
56
57 int permut, ind;
58
59 do
60 {
61 permut = 0;
62 for (int j = 1; j < 4; j++)
63 {
64 if (indice[j] < indice[j - 1])
65 {
66 ind = indice[j - 1];
67 indice[j - 1] = indice[j];
68 indice[j] = ind;
69 permut++;
70 }
71 }
72 }
73 while (permut);
74
75 for (int ii = 0; ii < nface; ii++)
76 {
77 if (fait_sommet(ii, 0) == indice[0] && fait_sommet(ii, 1) == indice[1] && fait_sommet(ii, 2) == indice[2])
78 {
79 i4 = fait_sommet(ii, 3);
80 break;
81 }
82 }
83
84 if (indice(4) < 0)
85 {
86 // Cerr << indice(0) << " " << indice(1) << " " << indice(2) << finl;
87 Cerr << " FALSE " << finl;
88 exit();
89 }
90 assert(indice(4) >= 0);
91
92 nouveaux(i, 0) = i0;
93 nouveaux(i, 1) = i1;
94 nouveaux(i, 2) = i4;
95
96 nouveaux(nb_faces + i, 0) = i1;
97 nouveaux(nb_faces + i, 1) = i3;
98 nouveaux(nb_faces + i, 2) = i4;
99
100 nouveaux(2 * nb_faces + i, 0) = i3;
101 nouveaux(2 * nb_faces + i, 1) = i2;
102 nouveaux(2 * nb_faces + i, 2) = i4;
103
104 nouveaux(3 * nb_faces + i, 0) = i2;
105 nouveaux(3 * nb_faces + i, 1) = i0;
106 nouveaux(3 * nb_faces + i, 2) = i4;
107
108 }
109 sommets.ref(nouveaux);
110}
111
112//
113// ATTENTION: ne considere qu'un seul domaine pour l'instant...
114//
115int Tetraedriser_homogene_compact::creer_sommet(Domaine& domaine, DoubleTab& new_soms, IntTab& elem_traite, IntTab& new_soms_old_elems, int NbSom, IntTab& sommets, int& compteur, int oldnbsom,
116 int& nbnewsoms, IntTab& fait_sommet, int& nface) const
117{
118
119 int _out = -1;
120 if (NbSom == 4) // On verifie que le sommet rattache a une face n'a pas ete cree ulterieurement
121 {
122 int permut, som;
123
124 do
125 {
126 permut = 0;
127 for (int j = 1; j < 4; j++)
128 {
129 if (sommets[j] < sommets[j - 1])
130 {
131 som = sommets[j - 1];
132 sommets[j - 1] = sommets[j];
133 sommets[j] = som;
134 permut++;
135 }
136 }
137 }
138 while (permut);
139
140 for (int i = 0; i < nface; i++)
141 if (fait_sommet(i, 0) == sommets[0] && fait_sommet(i, 1) == sommets[1] && fait_sommet(i, 2) == sommets[2])
142 return fait_sommet(i, 3);
143 }
144
145 const DoubleTab& coord_sommets = domaine.coord_sommets();
146
147 double x = 0, y = 0, z = 0;
148
149 for (int ii = 0; ii < NbSom; ii++)
150 {
151 x += coord_sommets(sommets(ii), 0);
152 y += coord_sommets(sommets(ii), 1);
153 z += coord_sommets(sommets(ii), 2);
154 }
155 x /= NbSom;
156 y /= NbSom;
157 z /= NbSom;
158
159 _out = oldnbsom + nbnewsoms;
160 new_soms(compteur, 0) = x;
161 new_soms(compteur, 1) = y;
162 new_soms(compteur, 2) = z;
163 nbnewsoms++;
164 compteur++;
165
166 if (NbSom == 4)
167 {
168 fait_sommet(nface, 0) = sommets[0];
169 fait_sommet(nface, 1) = sommets[1];
170 fait_sommet(nface, 2) = sommets[2];
171 fait_sommet(nface, 3) = _out;
172 // Cerr << sommets(0) << " " << sommets(1) << " " << sommets(2) << " " << _out << finl;
173 nface++;
174 }
175
176 return _out;
177}
178
179void Tetraedriser_homogene_compact::trianguler(Domaine& domaine) const
180{
181 if ((domaine.type_elem()->que_suis_je() == "Hexaedre") || (domaine.type_elem()->que_suis_je() == "Hexaedre_VEF"))
182 {
183 IntTab& les_elems = domaine.les_elems();
184 int oldsz = les_elems.dimension(0);
185 int nbs = domaine.nb_som();
186 IntTab elem_traite(oldsz);
187 int oldnbsom = domaine.nb_som();
188 IntTab new_elems(24 * oldsz, 4);
189 // pour chaque cube, liste des nouveaux sommets qu'il contient :
190 IntTab new_soms_old_elems(oldsz, 7);
191 IntTab sommets(8);
192 int compteur = 0;
193 int nbnewsoms = 0;
194 int nface = 0;
195 int i;
196
197 Cerr << " NB ELEM : " << oldsz << " NB NODE : " << nbs << finl;
198 IntTab fait_sommet(3 * nbs, 4); // PQ : 04-03 : dimensionnement de fait_sommet a 3*nbs (a revoir si insuffisant)
199 fait_sommet = -1;
200
201 // Construction de l'Octree sur la grille "VDF" de base
202
203 domaine.construit_octree();
204
205 //On dimensionne une premiere fois le tableau des sommets avec la dimension maximum
206 //puis on redimensionnera seulement a la fin par la dimension exacte
207
208 DoubleTab& sommets_dom = domaine.les_sommets();
209 //8 pour les nouveaux sommets et 8 pour les anciens sommets =16
210 int dim_som_max = 16 * oldsz;
211 int dim_som_old = sommets_dom.dimension(0);
212 sommets_dom.resize(dim_som_max, 3);
213
214 IntTab indice(8);
215 DoubleTab new_soms(7, 3);
216
217 for (i = 0; i < oldsz; i++)
218 {
219 if (nface >= 3 * nbs)
220 {
221 Cerr << " The sizing of the array fait_sommet in Tetraedriser_homogene_compact::Trianguler is inappropriate " << finl;
222 exit();
223 }
224
225 int i0 = les_elems(i, 0);
226 int i1 = les_elems(i, 1);
227 int i2 = les_elems(i, 2);
228 int i3 = les_elems(i, 3);
229 int i4 = les_elems(i, 4);
230 int i5 = les_elems(i, 5);
231 int i6 = les_elems(i, 6);
232 int i7 = les_elems(i, 7);
233
234 compteur = 0;
235
236 // Definition des nouveaux sommets : creation des barycentres
237 //centre de l'hexaedre
238
239 sommets(0) = i0;
240 sommets(1) = i1;
241 sommets(2) = i2;
242 sommets(3) = i3;
243 sommets(4) = i4;
244 sommets(5) = i5;
245 sommets(6) = i6;
246 sommets(7) = i7;
247 indice(0) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 8, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
248
249 //centres des faces bas (0-1-3-2)
250 sommets(0) = i0;
251 sommets(1) = i1;
252 sommets(2) = i3;
253 sommets(3) = i2;
254 indice(1) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
255
256 //centres des faces haut (4-5-7-6)
257 sommets(0) = i4;
258 sommets(1) = i5;
259 sommets(2) = i7;
260 sommets(3) = i6;
261 indice(4) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
262
263 //centres des faces avant (0-1-5-4)
264 sommets(0) = i0;
265 sommets(1) = i1;
266 sommets(2) = i5;
267 sommets(3) = i4;
268 indice(3) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
269
270 //centres des faces arriere (2-3-7-6)
271 sommets(0) = i2;
272 sommets(1) = i3;
273 sommets(2) = i7;
274 sommets(3) = i6;
275 indice(6) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
276
277 //centres des faces gauche (0-2-6-4)
278 sommets(0) = i0;
279 sommets(1) = i2;
280 sommets(2) = i6;
281 sommets(3) = i4;
282 indice(2) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
283
284 //centres des faces droite (1-3-7-5)
285 sommets(0) = i1;
286 sommets(1) = i3;
287 sommets(2) = i7;
288 sommets(3) = i5;
289 indice(5) = creer_sommet(domaine, new_soms, elem_traite, new_soms_old_elems, 4, sommets, compteur, oldnbsom, nbnewsoms, fait_sommet, nface);
290
291 // Liste des nouveaux sommets pour cet ancien cube
292 for (int t = 0; t < 7; t++)
293 {
294 new_soms_old_elems(i, t) = indice(t);
295 if (indice(t) < 0)
296 {
297 Cerr << "Error negative index" << finl;
298 exit();
299 }
300 for (int s = 0; s < t; s++)
301 if (indice(s) == indice(t))
302 {
303 Cerr << "Error repeated index" << finl;
304 exit();
305 }
306 }
307
308 for (int j = 0; j < compteur; j++)
309 for (int k = 0; k < 3; k++)
310 sommets_dom(dim_som_old + j, k) = new_soms(j, k);
311 dim_som_old += compteur;
312
313 // L'element en cours a ete "traite" en entier
314 elem_traite(i) = 1;
315
316 // pyramide bas (base : 0-1-3-2)
317
318 new_elems(i, 0) = les_elems(i, 0);
319 new_elems(i, 1) = les_elems(i, 1);
320 new_elems(i, 2) = indice(1);
321 new_elems(i, 3) = indice(0);
322
323 new_elems(i + oldsz, 0) = les_elems(i, 1);
324 new_elems(i + oldsz, 1) = les_elems(i, 3);
325 new_elems(i + oldsz, 2) = indice(1);
326 new_elems(i + oldsz, 3) = indice(0);
327 mettre_a_jour_sous_domaine(domaine, i, i + oldsz, 1);
328
329 new_elems(i + 2 * oldsz, 0) = les_elems(i, 3);
330 new_elems(i + 2 * oldsz, 1) = les_elems(i, 2);
331 new_elems(i + 2 * oldsz, 2) = indice(1);
332 new_elems(i + 2 * oldsz, 3) = indice(0);
333 mettre_a_jour_sous_domaine(domaine, i, i + 2 * oldsz, 1);
334
335 new_elems(i + 3 * oldsz, 0) = les_elems(i, 2);
336 new_elems(i + 3 * oldsz, 1) = les_elems(i, 0);
337 new_elems(i + 3 * oldsz, 2) = indice(1);
338 new_elems(i + 3 * oldsz, 3) = indice(0);
339 mettre_a_jour_sous_domaine(domaine, i, i + 3 * oldsz, 1);
340
341 // pyramide haut (base : 4-5-7-6)
342
343 new_elems(i + 4 * oldsz, 0) = les_elems(i, 4);
344 new_elems(i + 4 * oldsz, 1) = les_elems(i, 5);
345 new_elems(i + 4 * oldsz, 2) = indice(4);
346 new_elems(i + 4 * oldsz, 3) = indice(0);
347 mettre_a_jour_sous_domaine(domaine, i, i + 4 * oldsz, 1);
348
349 new_elems(i + 5 * oldsz, 0) = les_elems(i, 5);
350 new_elems(i + 5 * oldsz, 1) = les_elems(i, 7);
351 new_elems(i + 5 * oldsz, 2) = indice(4);
352 new_elems(i + 5 * oldsz, 3) = indice(0);
353 mettre_a_jour_sous_domaine(domaine, i, i + 5 * oldsz, 1);
354
355 new_elems(i + 6 * oldsz, 0) = les_elems(i, 7);
356 new_elems(i + 6 * oldsz, 1) = les_elems(i, 6);
357 new_elems(i + 6 * oldsz, 2) = indice(4);
358 new_elems(i + 6 * oldsz, 3) = indice(0);
359 mettre_a_jour_sous_domaine(domaine, i, i + 6 * oldsz, 1);
360
361 new_elems(i + 7 * oldsz, 0) = les_elems(i, 6);
362 new_elems(i + 7 * oldsz, 1) = les_elems(i, 4);
363 new_elems(i + 7 * oldsz, 2) = indice(4);
364 new_elems(i + 7 * oldsz, 3) = indice(0);
365 mettre_a_jour_sous_domaine(domaine, i, i + 7 * oldsz, 1);
366
367 // pyramide avant (base : 0-1-5-4)
368
369 new_elems(i + 8 * oldsz, 0) = les_elems(i, 0);
370 new_elems(i + 8 * oldsz, 1) = les_elems(i, 1);
371 new_elems(i + 8 * oldsz, 2) = indice(3);
372 new_elems(i + 8 * oldsz, 3) = indice(0);
373 mettre_a_jour_sous_domaine(domaine, i, i + 8 * oldsz, 1);
374
375 new_elems(i + 9 * oldsz, 0) = les_elems(i, 1);
376 new_elems(i + 9 * oldsz, 1) = les_elems(i, 5);
377 new_elems(i + 9 * oldsz, 2) = indice(3);
378 new_elems(i + 9 * oldsz, 3) = indice(0);
379 mettre_a_jour_sous_domaine(domaine, i, i + 9 * oldsz, 1);
380
381 new_elems(i + 10 * oldsz, 0) = les_elems(i, 5);
382 new_elems(i + 10 * oldsz, 1) = les_elems(i, 4);
383 new_elems(i + 10 * oldsz, 2) = indice(3);
384 new_elems(i + 10 * oldsz, 3) = indice(0);
385 mettre_a_jour_sous_domaine(domaine, i, i + 10 * oldsz, 1);
386
387 new_elems(i + 11 * oldsz, 0) = les_elems(i, 4);
388 new_elems(i + 11 * oldsz, 1) = les_elems(i, 0);
389 new_elems(i + 11 * oldsz, 2) = indice(3);
390 new_elems(i + 11 * oldsz, 3) = indice(0);
391 mettre_a_jour_sous_domaine(domaine, i, i + 11 * oldsz, 1);
392
393 // pyramide arriere (base : 2-3-7-6)
394
395 new_elems(i + 12 * oldsz, 0) = les_elems(i, 2);
396 new_elems(i + 12 * oldsz, 1) = les_elems(i, 3);
397 new_elems(i + 12 * oldsz, 2) = indice(6);
398 new_elems(i + 12 * oldsz, 3) = indice(0);
399 mettre_a_jour_sous_domaine(domaine, i, i + 12 * oldsz, 1);
400
401 new_elems(i + 13 * oldsz, 0) = les_elems(i, 3);
402 new_elems(i + 13 * oldsz, 1) = les_elems(i, 7);
403 new_elems(i + 13 * oldsz, 2) = indice(6);
404 new_elems(i + 13 * oldsz, 3) = indice(0);
405 mettre_a_jour_sous_domaine(domaine, i, i + 13 * oldsz, 1);
406
407 new_elems(i + 14 * oldsz, 0) = les_elems(i, 7);
408 new_elems(i + 14 * oldsz, 1) = les_elems(i, 6);
409 new_elems(i + 14 * oldsz, 2) = indice(6);
410 new_elems(i + 14 * oldsz, 3) = indice(0);
411 mettre_a_jour_sous_domaine(domaine, i, i + 14 * oldsz, 1);
412
413 new_elems(i + 15 * oldsz, 0) = les_elems(i, 6);
414 new_elems(i + 15 * oldsz, 1) = les_elems(i, 2);
415 new_elems(i + 15 * oldsz, 2) = indice(6);
416 new_elems(i + 15 * oldsz, 3) = indice(0);
417 mettre_a_jour_sous_domaine(domaine, i, i + 15 * oldsz, 1);
418
419 // pyramide gauche (base : 0-2-6-4)
420
421 new_elems(i + 16 * oldsz, 0) = les_elems(i, 0);
422 new_elems(i + 16 * oldsz, 1) = les_elems(i, 2);
423 new_elems(i + 16 * oldsz, 2) = indice(2);
424 new_elems(i + 16 * oldsz, 3) = indice(0);
425 mettre_a_jour_sous_domaine(domaine, i, i + 16 * oldsz, 1);
426
427 new_elems(i + 17 * oldsz, 0) = les_elems(i, 2);
428 new_elems(i + 17 * oldsz, 1) = les_elems(i, 6);
429 new_elems(i + 17 * oldsz, 2) = indice(2);
430 new_elems(i + 17 * oldsz, 3) = indice(0);
431 mettre_a_jour_sous_domaine(domaine, i, i + 17 * oldsz, 1);
432
433 new_elems(i + 18 * oldsz, 0) = les_elems(i, 6);
434 new_elems(i + 18 * oldsz, 1) = les_elems(i, 4);
435 new_elems(i + 18 * oldsz, 2) = indice(2);
436 new_elems(i + 18 * oldsz, 3) = indice(0);
437 mettre_a_jour_sous_domaine(domaine, i, i + 18 * oldsz, 1);
438
439 new_elems(i + 19 * oldsz, 0) = les_elems(i, 4);
440 new_elems(i + 19 * oldsz, 1) = les_elems(i, 0);
441 new_elems(i + 19 * oldsz, 2) = indice(2);
442 new_elems(i + 19 * oldsz, 3) = indice(0);
443 mettre_a_jour_sous_domaine(domaine, i, i + 19 * oldsz, 1);
444
445 // pyramide droite (base : 1-3-7-5)
446
447 new_elems(i + 20 * oldsz, 0) = les_elems(i, 1);
448 new_elems(i + 20 * oldsz, 1) = les_elems(i, 3);
449 new_elems(i + 20 * oldsz, 2) = indice(5);
450 new_elems(i + 20 * oldsz, 3) = indice(0);
451 mettre_a_jour_sous_domaine(domaine, i, i + 20 * oldsz, 1);
452
453 new_elems(i + 21 * oldsz, 0) = les_elems(i, 3);
454 new_elems(i + 21 * oldsz, 1) = les_elems(i, 7);
455 new_elems(i + 21 * oldsz, 2) = indice(5);
456 new_elems(i + 21 * oldsz, 3) = indice(0);
457 mettre_a_jour_sous_domaine(domaine, i, i + 21 * oldsz, 1);
458
459 new_elems(i + 22 * oldsz, 0) = les_elems(i, 7);
460 new_elems(i + 22 * oldsz, 1) = les_elems(i, 5);
461 new_elems(i + 22 * oldsz, 2) = indice(5);
462 new_elems(i + 22 * oldsz, 3) = indice(0);
463 mettre_a_jour_sous_domaine(domaine, i, i + 22 * oldsz, 1);
464
465 new_elems(i + 23 * oldsz, 0) = les_elems(i, 5);
466 new_elems(i + 23 * oldsz, 1) = les_elems(i, 1);
467 new_elems(i + 23 * oldsz, 2) = indice(5);
468 new_elems(i + 23 * oldsz, 3) = indice(0);
469 mettre_a_jour_sous_domaine(domaine, i, i + 23 * oldsz, 1);
470
471 }
472 sommets_dom.resize(dim_som_old, 3);
473 les_elems.ref(new_elems);
474
475 // Reconstruction de l'octree
476 Cerr << "We have split the cubes..." << finl;
477 domaine.invalide_octree();
478 domaine.typer("Tetraedre");
479
480 Cerr << "Splitting of the boundaries" << finl;
481 for (auto &itr : domaine.faces_bord())
482 {
483 Faces& les_faces = itr.faces();
484 les_faces.typer(Type_Face::triangle_3D);
485 decoupe(domaine, les_faces, new_soms_old_elems, fait_sommet, nface);
486 }
487
488 Cerr << "Splitting of the connectors" << finl;
489 for (auto &itr : domaine.faces_raccord())
490 {
491 Faces& les_faces = itr->faces();
492 les_faces.typer(Type_Face::triangle_3D);
493 decoupe(domaine, les_faces, new_soms_old_elems, fait_sommet, nface);
494 }
495
496 Cerr << "Splitting of the internal boundary faces" << finl;
497 for (auto &itr : domaine.bords_int())
498 {
499 Faces& les_faces = itr.faces();
500 les_faces.typer(Type_Face::triangle_3D);
501 decoupe(domaine, les_faces, new_soms_old_elems, fait_sommet, nface);
502 }
503
504 Cerr << "Splitting of the group of faces" << finl;
505 for (auto &itr : domaine.groupes_faces())
506 {
507 Faces& les_faces = itr.faces();
508 les_faces.typer(Type_Face::triangle_3D);
509 decoupe(domaine, les_faces, new_soms_old_elems, fait_sommet, nface);
510 }
511
512 Cerr << "END of Tetraedriser_homogene_compact..." << finl;
513 Cerr << " 1 NbElem=" << domaine.les_elems().dimension(0) << " NbNod=" << domaine.nb_som() << finl;
514 }
515 else
516 Cerr << "We do not yet know how to Tetraedriser_homogene_compact the " << domaine.type_elem()->que_suis_je() << "s" << finl;
517}
Entree
Class defining operators and methods for all reading operation in an input flow (file,...
Definition Entree.h:42
Faces_32_64::typer
void typer(const Motcle &)
Type les faces.
Definition Faces.cpp:390
Faces_32_64::voisins
IntTab_t & voisins()
Renvoie le tableau des voisins (des faces).
Definition Faces.h:89
Faces_32_64::les_sommets
const IntTab_t & les_sommets() const
Renvoie le tableau des sommets de toutes les faces.
Definition Faces.h:74
Interprete_geometrique_base_32_64< int >::mettre_a_jour_sous_domaine
void mettre_a_jour_sous_domaine(Domaine_t &domaine, int_t &elem, int_t num_premier_elem, int_t nb_elem) const
Interprete_geometrique_base_32_64< int >::domaine
Domaine_t & domaine(int i=0)
Definition Interprete_geometrique_base.h:48
Objet_U::readOn
virtual Entree & readOn(Entree &)
Lecture d'un Objet_U sur un flot d'entree Methode a surcharger.
Definition Objet_U.cpp:293
Objet_U::printOn
virtual Sortie & printOn(Sortie &) const
Ecriture de l'objet sur un flot de sortie Methode a surcharger.
Definition Objet_U.cpp:282
Process::exit
static void exit(int exit_code=-1)
Routine de sortie de TRUST dans une region Kokkos.
Definition Process.cpp:455
Sortie
Classe de base des flux de sortie.
Definition Sortie.h:52
TRUSTTab::ref
virtual void ref(const TRUSTTab &)
Definition TRUSTTab.tpp:308
TRUSTTab::resize
void resize(_SIZE_ n, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT)
Definition TRUSTTab.tpp:469
TRUSTTab::dimension
_SIZE_ dimension(int d) const
Definition TRUSTTab.tpp:133
Tetraedriser_homogene_compact
class Tetra_homogene_compact Realise un maillage en decoupant chaque pave en 40 tetraedres
Definition Tetraedriser_homogene_compact.h:35
Tetraedriser_homogene_compact::trianguler
void trianguler(Domaine &) const override
Definition Tetraedriser_homogene_compact.cpp:179
Tetraedriser_homogene_compact::decoupe
void decoupe(Domaine &, Faces &, IntTab &, IntTab &, int) const
Definition Tetraedriser_homogene_compact.cpp:32
Tetraedriser_homogene_compact::creer_sommet
int creer_sommet(Domaine &, DoubleTab &, IntTab &, IntTab &, int, IntTab &, int &, int, int &, IntTab &, int &) const
Definition Tetraedriser_homogene_compact.cpp:115
Triangulation_base
Triangulation_base Classe destinee a factoriser l'action de triangulation des interpretes.
Definition Triangulation_base.h:29