TrioCFD 1.9.9_beta
TrioCFD documentation
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// Face processing
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 // restore some order in the 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// WARNING: only considers a single domain for now...
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) // Check that the vertex attached to a face has not been created subsequently
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 // for each cube, list of new vertices it contains:
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 : sizing fait_sommet to 3*nbs (to revisit if insufficient)
199 fait_sommet = -1;
200
201 // Build the Octree on the base "VDF" grid
202
203 domaine.construit_octree();
204
205 //First dimension the array of vertices with the maximum size
206 //then resize only at the end to the exact dimension
207
208 DoubleTab& sommets_dom = domaine.les_sommets();
209 //8 for the new vertices and 8 for the old vertices =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 of new vertices: creation of barycenters
237 //center of the hexahedron
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 //centers of bottom faces (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 //centers of top faces (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 //centers of front faces (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 //centers of rear faces (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 //centers of left faces (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 //centers of right faces (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 // List of new vertices for this old 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 // The current element has been fully "processed"
314 elem_traite(i) = 1;
315
316 // bottom pyramid (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 // top pyramid (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 // front pyramid (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 // rear pyramid (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 // left pyramid (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 // right pyramid (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 // Rebuild the 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 &)
Sets the type of the faces.
Definition Faces.cpp:382
Faces_32_64::voisins
IntTab_t & voisins()
Returns the array of neighbors (of the faces).
Definition Faces.h:89
Faces_32_64::les_sommets
const IntTab_t & les_sommets() const
Returns the array of vertices of all 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 &)
Reads an Objet_U from an input stream. Virtual method to override.
Definition Objet_U.cpp:289
Objet_U::printOn
virtual Sortie & printOn(Sortie &) const
Writes the object to an output stream. Virtual method to override.
Definition Objet_U.cpp:278
Process::exit
static void exit(int exit_code=-1)
Exit routine for TRUST within a Kokkos region.
Definition Process.cpp:466
Sortie
Base class for output streams.
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 Creates a mesh by splitting each block into 40 tetrahedra.
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 Base class intended to factor out the triangulation action of interpreters.
Definition Triangulation_base.h:28