Arcane  v3.16.9.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ItemTypeMng.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ItemTypeMng.cc (C) 2000-2025 */
9/* */
10/* Gestionnaire des types d'entite du maillage. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/ItemTypeMng.h"
15
16#include "ItemTypeId.h"
17#include "arcane/utils/Iostream.h"
18#include "arcane/utils/String.h"
19#include "arcane/utils/PlatformUtils.h"
20#include "arcane/utils/ITraceMng.h"
21#include "arcane/utils/TraceAccessor.h"
22#include "arcane/utils/IStackTraceService.h"
23#include "arcane/utils/IOException.h"
24#include "arcane/utils/FatalErrorException.h"
25#include "arcane/utils/Array.h"
26#include "arcane/utils/MultiBuffer.h"
27
28#include "arcane/core/ItemTypeInfoBuilder.h"
29#include "arcane/core/IParallelSuperMng.h"
30#include "arcane/core/ItemTypeInfoBuilder.h"
31#include "arcane/core/IMesh.h"
32#include "arcane/core/MeshKind.h"
33#include "arcane/core/ISubDomain.h"
34#include "arcane/core/IApplication.h"
35
36// AMR
37#include "arcane/ItemRefinementPattern.h"
38
39#include <map>
40#include <set>
41
42/*---------------------------------------------------------------------------*/
43/*---------------------------------------------------------------------------*/
44
45namespace Arcane
46{
47
48/*---------------------------------------------------------------------------*/
49/*---------------------------------------------------------------------------*/
50
51const Integer ItemTypeMng::m_nb_builtin_item_type = NB_BASIC_ITEM_TYPE;
52
53/*---------------------------------------------------------------------------*/
54/*---------------------------------------------------------------------------*/
55
60
61/*---------------------------------------------------------------------------*/
62/*---------------------------------------------------------------------------*/
63
64ItemTypeMng::
65~ItemTypeMng()
66{
67 delete m_types_buffer;
68}
69
70/*---------------------------------------------------------------------------*/
71/*---------------------------------------------------------------------------*/
72
74build(IMesh* mesh)
75{
76 if (m_initialized)
77 ARCANE_FATAL("ItemTypeMng instance is already initialized");
78 // Récupère le IParallelSuperMng via l'application.
79 // Une fois qu'on aura supprimé l'instance singleton, on pourra
80 // simplement utiliser le IParallelMng.
81 IParallelSuperMng* super_pm = mesh->subDomain()->application()->parallelSuperMng();
82 _buildTypes(mesh, super_pm, mesh->traceMng());
83 m_initialized = true;
84}
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
88
90build(IParallelSuperMng* parallel_mng, ITraceMng* trace)
91{
92 _buildSingleton(parallel_mng, trace);
93}
94
95/*---------------------------------------------------------------------------*/
96/*---------------------------------------------------------------------------*/
97
98void ItemTypeMng::
99_buildSingleton(IParallelSuperMng* parallel_mng, ITraceMng* trace)
100{
101 // Avec MPC, cette fonction peut être appelée plusieurs fois
102 // dans des threads différents. Comme tous les threads partagent
103 // le même singleton, seul le premier thread fait réellement l'initialisation.
104 // ATTENTION: Cela est incompatible avec le mode readTypes()
105 // ou on lit les connectivités dans un fichier ARCANE_ITEM_TYPE_FILE.
106 Int32 max_rank = parallel_mng->commSize() + 1;
107 Int32 init_counter = ++m_initialized_counter;
108 if (init_counter == 1) {
109 _buildTypes(nullptr, parallel_mng, trace);
110 m_initialized = true;
111 m_initialized_counter = max_rank;
112 }
113 else
114 // Ceux qui ne font pas l'initialisation doivent attendre que cette dernière
115 // soit faite.
116 while (init_counter < max_rank)
117 init_counter = m_initialized_counter.load();
118}
119
120/*---------------------------------------------------------------------------*/
121/*---------------------------------------------------------------------------*/
122/*!
123 * \brief Construit les types des entités.
124 *
125 * \note Pour l'instance singleton, \a mesh est nul.
126 */
127void ItemTypeMng::
128_buildTypes(IMesh* mesh, IParallelSuperMng* parallel_mng, ITraceMng* trace)
129{
130 // Construit la connectivité des éléments.
131 // Pour les éléments classiques, la connectivité est la même que
132 // celle de VTK, disponible dans le document:
133 //
134 // https://vtk.org/wp-content/uploads/2015/04/file-formats.pdf
135
136 using Dimension = ItemTypeInfoBuilder::Dimension;
137 bool is_non_manifold = false;
138 if (mesh)
139 is_non_manifold = mesh->meshKind().isNonManifold();
140
141 m_trace = trace;
142 m_types.resize(m_nb_builtin_item_type);
143 m_types_buffer = new MultiBufferT<ItemTypeInfoBuilder>();
144
145 // Null
146 {
147 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
148 m_types[IT_NullType] = type;
149
150 type->setInfos(this, IT_NullType, "NullType", Dimension::DimUnknown, 0, 0, 0);
151 }
152
153 // Vertex
154 {
155 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
156 m_types[IT_Vertex] = type;
157
158 type->setInfos(this, IT_Vertex, "Vertex", Dimension::Dim0, 0, 0, 0);
159 // TODO regarder si ce type est autorisé pour les mailles.
160 // Si ce n'est pas le cas, il faudrait définir un type
161 // pour les mailles 0D qui sont assimilables à des points.
162 }
163
164 // FaceVertex (face pour les maillages 1D)
165 {
166 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
167 m_types[IT_FaceVertex] = type;
168
169 type->setInfos(this, IT_FaceVertex, "FaceVertex", Dimension::Dim0, 1, 0, 0);
170 type->setIsValidForCell(false);
171 }
172
173 // Line2
174 {
175 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
176 m_types[IT_Line2] = type;
177
178 type->setInfos(this, IT_Line2, "Line2", Dimension::Dim1, 2, 0, 0);
179 type->setIsValidForCell(true);
180 }
181
182 // Line3
183 {
184 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
185 m_types[IT_Line3] = type;
186 type->setOrder(2, ITI_Line2);
187
188 type->setInfos(this, IT_Line3, "Line3", Dimension::Dim1, 3, 0, 0);
189 type->setIsValidForCell(false);
190 }
191
192 // CellLine2 (mailles pour les maillages 1D)
193 {
194 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
195 m_types[IT_CellLine2] = type;
196
197 type->setInfos(this, IT_CellLine2, "CellLine2", Dimension::Dim1, 2, 0, 2);
198
199 type->addFaceVertex(0, 0);
200 type->addFaceVertex(1, 1);
201 }
202
203 /**
204 * SDP: Pour les polygones les faces et les arêtes sont identiques.
205 *
206 * @note lors des declarations des arêtes, on donne pour faces les
207 * arêtes qui sont jointes a l'arête courante
208 */
209
210 // Triangle3
211 {
212 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
213 m_types[IT_Triangle3] = type;
214
215 type->setInfos(this, IT_Triangle3, "Triangle3", Dimension::Dim2, 3, 3, 3);
216
217 type->addEdgeAndFaceLine(0, { 0, 1 }, { 1, 2 });
218 type->addEdgeAndFaceLine(1, { 1, 2 }, { 2, 0 });
219 type->addEdgeAndFaceLine(2, { 2, 0 }, { 0, 1 });
220 }
221
222 // Triangle6
223 {
224 // TODO: Pour l'instant comme triangle3
225 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
226 m_types[IT_Triangle6] = type;
227
228 type->setInfos(this, IT_Triangle6, "Triangle6", Dimension::Dim2, 6, 3, 3);
229 type->setOrder(2, ITI_Triangle3);
230
231 type->addFaceLine3(0, 0, 1, 3);
232 type->addFaceLine3(1, 1, 2, 4);
233 type->addFaceLine3(2, 2, 0, 5);
234
235 type->addEdge(0, 0, 1, 1, 2);
236 type->addEdge(1, 1, 2, 2, 0);
237 type->addEdge(2, 2, 0, 0, 1);
238 }
239
240 // Quad4
241 {
242 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
243 m_types[IT_Quad4] = type;
244
245 type->setInfos(this, IT_Quad4, "Quad4", Dimension::Dim2, 4, 4, 4);
246
247 type->addEdgeAndFaceLine(0, { 0, 1 }, { 3, 1 });
248 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
249 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
250 type->addEdgeAndFaceLine(3, { 3, 0 }, { 2, 0 });
251 }
252
253 // Quad8
254 {
255 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
256 m_types[IT_Quad8] = type;
257
258 type->setInfos(this, IT_Quad8, "Quad8", Dimension::Dim2, 8, 4, 4);
259 type->setOrder(2, ITI_Quad4);
260
261 type->addFaceLine3(0, 0, 1, 4);
262 type->addFaceLine3(1, 1, 2, 5);
263 type->addFaceLine3(2, 2, 3, 6);
264 type->addFaceLine3(3, 3, 0, 7);
265
266 type->addEdge(0, 0, 1, 3, 1);
267 type->addEdge(1, 1, 2, 0, 2);
268 type->addEdge(2, 2, 3, 1, 3);
269 type->addEdge(3, 3, 0, 2, 0);
270 }
271
272 // Quad9
273 {
274 // Comme Quad8 mais avec un noeud en plus au milieu du quadrangle
275 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
276 m_types[IT_Quad9] = type;
277
278 type->setInfos(this, IT_Quad9, "Quad9", Dimension::Dim2, 9, 4, 4);
279 type->setOrder(2, ITI_Quad4);
280 type->setHasCenterNode(true);
281
282 type->addFaceLine3(0, 0, 1, 4);
283 type->addFaceLine3(1, 1, 2, 5);
284 type->addFaceLine3(2, 2, 3, 6);
285 type->addFaceLine3(3, 3, 0, 7);
286
287 type->addEdge(0, 0, 1, 3, 1);
288 type->addEdge(1, 1, 2, 0, 2);
289 type->addEdge(2, 2, 3, 1, 3);
290 type->addEdge(3, 3, 0, 2, 0);
291 }
292
293 // Pentagon5
294 {
295 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
296 m_types[IT_Pentagon5] = type;
297
298 type->setInfos(this, IT_Pentagon5, "Pentagon5", Dimension::Dim2, 5, 5, 5);
299
300 type->addFaceLine(0, 0, 1);
301 type->addFaceLine(1, 1, 2);
302 type->addFaceLine(2, 2, 3);
303 type->addFaceLine(3, 3, 4);
304 type->addFaceLine(4, 4, 0);
305
306 type->addEdge(0, 0, 1, 4, 1);
307 type->addEdge(1, 1, 2, 0, 2);
308 type->addEdge(2, 2, 3, 1, 3);
309 type->addEdge(3, 3, 4, 2, 4);
310 type->addEdge(4, 4, 0, 3, 0);
311 }
312
313 // Hexagon6
314 {
315 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
316 m_types[IT_Hexagon6] = type;
317
318 type->setInfos(this, IT_Hexagon6, "Hexagon6", Dimension::Dim2, 6, 6, 6);
319
320 type->addFaceLine(0, 0, 1);
321 type->addFaceLine(1, 1, 2);
322 type->addFaceLine(2, 2, 3);
323 type->addFaceLine(3, 3, 4);
324 type->addFaceLine(4, 4, 5);
325 type->addFaceLine(5, 5, 0);
326
327 type->addEdge(0, 0, 1, 5, 1);
328 type->addEdge(1, 1, 2, 0, 2);
329 type->addEdge(2, 2, 3, 1, 3);
330 type->addEdge(3, 3, 4, 2, 4);
331 type->addEdge(4, 4, 5, 3, 5);
332 type->addEdge(5, 5, 0, 4, 0);
333 }
334
335 // Hexaedron8
336 {
337 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
338 m_types[IT_Hexaedron8] = type;
339
340 type->setInfos(this, IT_Hexaedron8, "Hexaedron8", Dimension::Dim3, 8, 12, 6);
341
342 type->addFaceQuad(0, 0, 3, 2, 1);
343 type->addFaceQuad(1, 0, 4, 7, 3);
344 type->addFaceQuad(2, 0, 1, 5, 4);
345 type->addFaceQuad(3, 4, 5, 6, 7);
346 type->addFaceQuad(4, 1, 2, 6, 5);
347 type->addFaceQuad(5, 2, 3, 7, 6);
348
349 type->addEdge(0, 0, 1, 2, 0);
350 type->addEdge(1, 1, 2, 4, 0);
351 type->addEdge(2, 2, 3, 5, 0);
352 type->addEdge(3, 3, 0, 1, 0);
353 type->addEdge(4, 0, 4, 1, 2);
354 type->addEdge(5, 1, 5, 2, 4);
355 type->addEdge(6, 2, 6, 4, 5);
356 type->addEdge(7, 3, 7, 5, 1);
357 type->addEdge(8, 4, 5, 3, 2);
358 type->addEdge(9, 5, 6, 3, 4);
359 type->addEdge(10, 6, 7, 3, 5);
360 type->addEdge(11, 7, 4, 3, 1);
361 }
362
363 // Hexaedron20
364 {
365 // Pour l'instant comme Hexaedron8
366 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
367 m_types[IT_Hexaedron20] = type;
368
369 type->setInfos(this, IT_Hexaedron20, "Hexaedron20", Dimension::Dim3, 20, 12, 6);
370 type->setOrder(2, ITI_Hexaedron8);
371
372 type->addFaceQuad8(0, 0, 3, 2, 1, 11, 10, 9, 8);
373 type->addFaceQuad8(1, 0, 4, 7, 3, 16, 15, 19, 11);
374 type->addFaceQuad8(2, 0, 1, 5, 4, 8, 17, 12, 16);
375 type->addFaceQuad8(3, 4, 5, 6, 7, 12, 13, 14, 15);
376 type->addFaceQuad8(4, 1, 2, 6, 5, 9, 18, 13, 17);
377 type->addFaceQuad8(5, 2, 3, 7, 6, 10, 19, 14, 18);
378
379 type->addEdge(0, 0, 1, 2, 0);
380 type->addEdge(1, 1, 2, 4, 0);
381 type->addEdge(2, 2, 3, 5, 0);
382 type->addEdge(3, 3, 0, 1, 0);
383 type->addEdge(4, 0, 4, 1, 2);
384 type->addEdge(5, 1, 5, 2, 4);
385 type->addEdge(6, 2, 6, 4, 5);
386 type->addEdge(7, 3, 7, 5, 1);
387 type->addEdge(8, 4, 5, 3, 2);
388 type->addEdge(9, 5, 6, 3, 4);
389 type->addEdge(10, 6, 7, 3, 5);
390 type->addEdge(11, 7, 4, 3, 1);
391 }
392
393 // Hexaedron27
394 {
395 // Pour l'instant comme Hexaedron8
396 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
397 m_types[IT_Hexaedron27] = type;
398
399 type->setInfos(this, IT_Hexaedron27, "Hexaedron27", Dimension::Dim3, 27, 12, 6);
400 type->setOrder(2, ITI_Hexaedron8);
401 type->setHasCenterNode(true);
402
403 type->addFaceQuad9(0, 0, 3, 2, 1, 11, 10, 9, 8, 24);
404 type->addFaceQuad9(1, 0, 4, 7, 3, 16, 15, 19, 11, 20);
405 type->addFaceQuad9(2, 0, 1, 5, 4, 8, 17, 12, 16, 22);
406 type->addFaceQuad9(3, 4, 5, 6, 7, 12, 13, 14, 15, 25);
407 type->addFaceQuad9(4, 1, 2, 6, 5, 9, 18, 13, 17, 21);
408 type->addFaceQuad9(5, 2, 3, 7, 6, 10, 19, 14, 18, 23);
409
410 type->addEdge(0, 0, 1, 2, 0);
411 type->addEdge(1, 1, 2, 4, 0);
412 type->addEdge(2, 2, 3, 5, 0);
413 type->addEdge(3, 3, 0, 1, 0);
414 type->addEdge(4, 0, 4, 1, 2);
415 type->addEdge(5, 1, 5, 2, 4);
416 type->addEdge(6, 2, 6, 4, 5);
417 type->addEdge(7, 3, 7, 5, 1);
418 type->addEdge(8, 4, 5, 3, 2);
419 type->addEdge(9, 5, 6, 3, 4);
420 type->addEdge(10, 6, 7, 3, 5);
421 type->addEdge(11, 7, 4, 3, 1);
422 }
423
424 // Pyramid5
425 {
426 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
427 m_types[IT_Pyramid5] = type;
428
429 type->setInfos(this, IT_Pyramid5, "Pyramid5", Dimension::Dim3, 5, 8, 5);
430
431 type->addFaceQuad(0, 0, 3, 2, 1);
432 type->addFaceTriangle(1, 0, 4, 3);
433 type->addFaceTriangle(2, 0, 1, 4);
434 type->addFaceTriangle(3, 1, 2, 4);
435 type->addFaceTriangle(4, 2, 3, 4);
436
437 type->addEdge(0, 0, 1, 2, 0);
438 type->addEdge(1, 1, 2, 3, 0);
439 type->addEdge(2, 2, 3, 4, 0);
440 type->addEdge(3, 3, 0, 1, 0);
441 type->addEdge(4, 0, 4, 1, 2);
442 type->addEdge(5, 1, 4, 2, 3);
443 type->addEdge(6, 2, 4, 3, 4);
444 type->addEdge(7, 3, 4, 4, 1);
445 }
446
447 // Pyramid13
448 {
449 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
450 m_types[IT_Pyramid13] = type;
451 type->setOrder(2, ITI_Pyramid5);
452 type->setInfos(this, IT_Pyramid13, "Pyramid13", Dimension::Dim3, 13, 8, 5);
453
454 type->addFaceQuad8(0, 0, 3, 2, 1, 5, 6, 7, 8);
455 type->addFaceTriangle6(1, 0, 4, 3, 9, 12, 8);
456 type->addFaceTriangle6(2, 0, 1, 4, 5, 10, 9);
457 type->addFaceTriangle6(3, 1, 2, 4, 6, 11, 10);
458 type->addFaceTriangle6(4, 2, 3, 4, 7, 12, 11);
459
460 type->addEdge(0, 0, 1, 2, 0);
461 type->addEdge(1, 1, 2, 3, 0);
462 type->addEdge(2, 2, 3, 4, 0);
463 type->addEdge(3, 3, 0, 1, 0);
464 type->addEdge(4, 0, 4, 1, 2);
465 type->addEdge(5, 1, 4, 2, 3);
466 type->addEdge(6, 2, 4, 3, 4);
467 type->addEdge(7, 3, 4, 4, 1);
468 }
469
470 // Pentaedron6
471 {
472 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
473 m_types[IT_Pentaedron6] = type;
474
475 type->setInfos(this, IT_Pentaedron6, "Pentaedron6", Dimension::Dim3, 6, 9, 5);
476
477 type->addFaceTriangle(0, 0, 2, 1);
478 type->addFaceQuad(1, 0, 3, 5, 2);
479 type->addFaceQuad(2, 0, 1, 4, 3);
480 type->addFaceTriangle(3, 3, 4, 5);
481 type->addFaceQuad(4, 1, 2, 5, 4);
482
483 type->addEdge(0, 0, 1, 2, 0);
484 type->addEdge(1, 1, 2, 4, 0);
485 type->addEdge(2, 2, 0, 1, 0);
486 type->addEdge(3, 0, 3, 1, 2);
487 type->addEdge(4, 1, 4, 2, 4);
488 type->addEdge(5, 2, 5, 4, 1);
489 type->addEdge(6, 3, 4, 3, 2);
490 type->addEdge(7, 4, 5, 3, 4);
491 type->addEdge(8, 5, 3, 3, 1);
492 }
493
494 // Pentaedron15
495 {
496 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
497 m_types[IT_Pentaedron15] = type;
498 type->setOrder(2, ITI_Pentaedron15);
499
500 type->setInfos(this, IT_Pentaedron15, "Pentaedron15", Dimension::Dim3, 15, 9, 5);
501
502 type->addFaceTriangle6(0, 0, 2, 1, 6, 7, 8);
503 type->addFaceQuad8(1, 0, 3, 5, 2, 12, 11, 14, 8);
504 type->addFaceQuad8(2, 0, 1, 4, 3, 6, 13, 9, 3);
505 type->addFaceTriangle6(3, 3, 4, 5, 9, 10, 11);
506 type->addFaceQuad8(4, 1, 2, 5, 4, 7, 14, 10, 13);
507
508 type->addEdge(0, 0, 1, 2, 0);
509 type->addEdge(1, 1, 2, 4, 0);
510 type->addEdge(2, 2, 0, 1, 0);
511 type->addEdge(3, 0, 3, 1, 2);
512 type->addEdge(4, 1, 4, 2, 4);
513 type->addEdge(5, 2, 5, 4, 1);
514 type->addEdge(6, 3, 4, 3, 2);
515 type->addEdge(7, 4, 5, 3, 4);
516 type->addEdge(8, 5, 3, 3, 1);
517 }
518
519 // Tetraedron4
520 {
521 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
522 m_types[IT_Tetraedron4] = type;
523
524 type->setInfos(this, IT_Tetraedron4, "Tetraedron4", Dimension::Dim3, 4, 6, 4);
525
526 type->addFaceTriangle(0, 0, 2, 1);
527 type->addFaceTriangle(1, 0, 3, 2);
528 type->addFaceTriangle(2, 0, 1, 3);
529 type->addFaceTriangle(3, 1, 2, 3);
530
531 type->addEdge(0, 0, 1, 2, 0);
532 type->addEdge(1, 1, 2, 3, 0);
533 type->addEdge(2, 2, 0, 1, 0);
534 type->addEdge(3, 0, 3, 1, 2);
535 type->addEdge(4, 1, 3, 2, 3);
536 type->addEdge(5, 2, 3, 3, 1);
537 }
538
539 // Tetraedron10
540 {
541 // Pour l'instant comme Tetraedron4
542 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
543 m_types[IT_Tetraedron10] = type;
544
545 type->setInfos(this, IT_Tetraedron10, "Tetraedron10", Dimension::Dim3, 10, 6, 4);
546 type->setOrder(2, ITI_Tetraedron4);
547
548 type->addFaceTriangle6(0, 0, 2, 1, 6, 5, 4);
549 type->addFaceTriangle6(1, 0, 3, 2, 7, 9, 6);
550 type->addFaceTriangle6(2, 0, 1, 3, 4, 8, 7);
551 type->addFaceTriangle6(3, 1, 2, 3, 5, 9, 8);
552
553 type->addEdge(0, 0, 1, 2, 0);
554 type->addEdge(1, 1, 2, 3, 0);
555 type->addEdge(2, 2, 0, 1, 0);
556 type->addEdge(3, 0, 3, 1, 2);
557 type->addEdge(4, 1, 3, 2, 3);
558 type->addEdge(5, 2, 3, 3, 1);
559 }
560
561 // Heptaedron10
562 {
563 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
564 m_types[IT_Heptaedron10] = type;
565
566 type->setInfos(this, IT_Heptaedron10, "Heptaedron10", Dimension::Dim3, 10, 15, 7);
567
568 type->addFacePentagon(0, 0, 4, 3, 2, 1);
569 type->addFacePentagon(1, 5, 6, 7, 8, 9);
570 type->addFaceQuad(2, 0, 1, 6, 5);
571 type->addFaceQuad(3, 1, 2, 7, 6);
572 type->addFaceQuad(4, 2, 3, 8, 7);
573 type->addFaceQuad(5, 3, 4, 9, 8);
574 type->addFaceQuad(6, 4, 0, 5, 9);
575
576 type->addEdge(0, 0, 1, 2, 0);
577 type->addEdge(1, 1, 2, 3, 0);
578 type->addEdge(2, 2, 3, 4, 0);
579 type->addEdge(3, 3, 4, 5, 0);
580 type->addEdge(4, 4, 0, 6, 0);
581 type->addEdge(5, 5, 6, 1, 2);
582 type->addEdge(6, 6, 7, 1, 3);
583 type->addEdge(7, 7, 8, 1, 4);
584 type->addEdge(8, 8, 9, 1, 5);
585 type->addEdge(9, 9, 5, 1, 6);
586 type->addEdge(10, 0, 5, 6, 2);
587 type->addEdge(11, 1, 6, 2, 3);
588 type->addEdge(12, 2, 7, 3, 4);
589 type->addEdge(13, 3, 8, 4, 5);
590 type->addEdge(14, 4, 9, 5, 6);
591 }
592
593 // Octaedron12
594 {
595 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
596 m_types[IT_Octaedron12] = type;
597
598 type->setInfos(this, IT_Octaedron12, "Octaedron12", Dimension::Dim3, 12, 18, 8);
599
600 type->addFaceHexagon(0, 0, 5, 4, 3, 2, 1);
601 type->addFaceHexagon(1, 6, 7, 8, 9, 10, 11);
602 type->addFaceQuad(2, 0, 1, 7, 6);
603 type->addFaceQuad(3, 1, 2, 8, 7);
604 type->addFaceQuad(4, 2, 3, 9, 8);
605 type->addFaceQuad(5, 3, 4, 10, 9);
606 type->addFaceQuad(6, 4, 5, 11, 10);
607 type->addFaceQuad(7, 5, 0, 6, 11);
608
609 type->addEdge(0, 0, 1, 2, 0);
610 type->addEdge(1, 1, 2, 3, 0);
611 type->addEdge(2, 2, 3, 4, 0);
612 type->addEdge(3, 3, 4, 5, 0);
613 type->addEdge(4, 4, 5, 6, 0);
614 type->addEdge(5, 5, 0, 7, 0);
615 type->addEdge(6, 6, 7, 1, 2);
616 type->addEdge(7, 7, 8, 1, 3);
617 type->addEdge(8, 8, 9, 1, 4);
618 type->addEdge(9, 9, 10, 1, 5);
619 type->addEdge(10, 10, 11, 1, 6);
620 type->addEdge(11, 11, 6, 1, 7);
621 type->addEdge(12, 0, 6, 7, 2);
622 type->addEdge(13, 1, 7, 2, 3);
623 type->addEdge(14, 2, 8, 3, 4);
624 type->addEdge(15, 3, 9, 4, 5);
625 type->addEdge(16, 4, 10, 5, 6);
626 type->addEdge(17, 5, 11, 6, 7);
627 }
628
629 // HemiHexa7
630 {
631 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
632 m_types[IT_HemiHexa7] = type;
633
634 type->setInfos(this, IT_HemiHexa7, "HemiHexa7", Dimension::Dim3, 7, 11, 6);
635
636 type->addFaceTriangle(0, 0, 1, 2);
637 type->addFaceQuad(1, 0, 2, 3, 4);
638 type->addFaceQuad(2, 0, 5, 6, 1);
639 type->addFaceTriangle(3, 0, 4, 5);
640 type->addFaceQuad(4, 1, 6, 3, 2);
641 type->addFaceQuad(5, 3, 6, 5, 4);
642
643 type->addEdge(0, 0, 1, 0, 2);
644 type->addEdge(1, 1, 2, 0, 4);
645 type->addEdge(2, 2, 0, 0, 1);
646 type->addEdge(3, 2, 3, 1, 4);
647 type->addEdge(4, 3, 4, 1, 5);
648 type->addEdge(5, 4, 5, 3, 5);
649 type->addEdge(6, 5, 0, 3, 2);
650 type->addEdge(7, 0, 4, 3, 1);
651 type->addEdge(8, 5, 6, 2, 5);
652 type->addEdge(9, 6, 1, 2, 4);
653 type->addEdge(10, 3, 6, 5, 4);
654 }
655
656 // HemiHexa6
657 {
658 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
659 m_types[IT_HemiHexa6] = type;
660
661 type->setInfos(this, IT_HemiHexa6, "HemiHexa6", Dimension::Dim3, 6, 10, 6);
662
663 type->addFaceTriangle(0, 0, 1, 2);
664 type->addFaceQuad(1, 0, 2, 3, 4);
665 type->addFaceQuad(2, 0, 5, 3, 1);
666 type->addFaceTriangle(3, 0, 4, 5);
667 type->addFaceTriangle(4, 1, 3, 2);
668 type->addFaceTriangle(5, 3, 5, 4);
669
670 type->addEdge(0, 0, 1, 0, 2);
671 type->addEdge(1, 1, 2, 0, 4);
672 type->addEdge(2, 2, 0, 0, 1);
673 type->addEdge(3, 2, 3, 1, 4);
674 type->addEdge(4, 3, 4, 1, 5);
675 type->addEdge(5, 4, 5, 3, 5);
676 type->addEdge(6, 5, 0, 3, 2);
677 type->addEdge(7, 0, 4, 3, 1);
678 type->addEdge(8, 5, 3, 2, 5);
679 type->addEdge(9, 3, 1, 2, 4);
680 }
681
682 // HemiHexa5
683 {
684 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
685 m_types[IT_HemiHexa5] = type;
686
687 type->setInfos(this, IT_HemiHexa5, "HemiHexa5", Dimension::Dim3, 5, 7, 4);
688
689 type->addFaceTriangle(0, 0, 1, 2);
690 type->addFaceQuad(1, 0, 2, 3, 4);
691 type->addFaceQuad(2, 0, 4, 3, 1);
692 type->addFaceTriangle(3, 1, 3, 2);
693
694 type->addEdge(0, 0, 1, 0, 2);
695 type->addEdge(1, 1, 2, 0, 3);
696 type->addEdge(2, 2, 0, 0, 1);
697 type->addEdge(3, 2, 3, 1, 3);
698 type->addEdge(4, 3, 1, 2, 3);
699 type->addEdge(5, 3, 4, 1, 2);
700 type->addEdge(6, 4, 0, 1, 2);
701 }
702
703 // AntiWedgeLeft6
704 {
705 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
706 m_types[IT_AntiWedgeLeft6] = type;
707
708 type->setInfos(this, IT_AntiWedgeLeft6, "AntiWedgeLeft6", Dimension::Dim3, 6, 10, 6);
709
710 type->addFaceTriangle(0, 0, 2, 1);
711 type->addFaceQuad(1, 0, 3, 5, 2);
712 type->addFaceQuad(2, 0, 1, 4, 3);
713 type->addFaceTriangle(3, 3, 4, 5);
714 type->addFaceTriangle(4, 1, 2, 4);
715 type->addFaceTriangle(5, 2, 5, 4);
716
717 type->addEdge(0, 0, 1, 0, 2);
718 type->addEdge(1, 1, 2, 4, 0);
719 type->addEdge(2, 2, 0, 1, 0);
720 type->addEdge(3, 0, 3, 1, 2);
721 type->addEdge(4, 1, 4, 2, 4);
722 type->addEdge(5, 2, 5, 5, 1);
723 type->addEdge(6, 3, 4, 3, 2);
724 type->addEdge(7, 4, 5, 3, 5);
725 type->addEdge(8, 5, 3, 3, 1);
726 type->addEdge(9, 2, 4, 4, 5);
727 }
728
729 // AntiWedgeRight6
730 {
731 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
732 m_types[IT_AntiWedgeRight6] = type;
733
734 type->setInfos(this, IT_AntiWedgeRight6, "AntiWedgeRight6", Dimension::Dim3, 6, 10, 6);
735
736 type->addFaceTriangle(0, 0, 2, 1);
737 type->addFaceQuad(1, 0, 3, 5, 2);
738 type->addFaceQuad(2, 0, 1, 4, 3);
739 type->addFaceTriangle(3, 3, 4, 5);
740 type->addFaceTriangle(4, 1, 2, 5);
741 type->addFaceTriangle(5, 1, 5, 4);
742
743 type->addEdge(0, 0, 1, 0, 2);
744 type->addEdge(1, 1, 2, 4, 0);
745 type->addEdge(2, 2, 0, 1, 0);
746 type->addEdge(3, 0, 3, 1, 2);
747 type->addEdge(4, 1, 4, 2, 5);
748 type->addEdge(5, 2, 5, 4, 1);
749 type->addEdge(6, 3, 4, 3, 2);
750 type->addEdge(7, 4, 5, 3, 5);
751 type->addEdge(8, 5, 3, 3, 1);
752 type->addEdge(9, 1, 5, 5, 4);
753 }
754
755 // DiTetra5
756 {
757 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
758 m_types[IT_DiTetra5] = type;
759
760 type->setInfos(this, IT_DiTetra5, "DiTetra5", Dimension::Dim3, 5, 9, 6);
761
762 type->addFaceTriangle(0, 0, 1, 3);
763 type->addFaceTriangle(1, 1, 2, 3);
764 type->addFaceTriangle(2, 2, 0, 3);
765 type->addFaceTriangle(3, 1, 0, 4);
766 type->addFaceTriangle(4, 2, 1, 4);
767 type->addFaceTriangle(5, 0, 2, 4);
768
769 type->addEdge(0, 0, 1, 0, 3);
770 type->addEdge(1, 1, 2, 1, 4);
771 type->addEdge(2, 2, 0, 2, 5);
772 type->addEdge(3, 0, 3, 2, 0);
773 type->addEdge(4, 1, 3, 0, 1);
774 type->addEdge(5, 2, 3, 1, 2);
775 type->addEdge(6, 0, 4, 3, 5);
776 type->addEdge(7, 1, 4, 4, 3);
777 type->addEdge(8, 2, 4, 5, 4);
778 }
779
780 // DualNode
781 {
782 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
783 m_types[IT_DualNode] = type;
784
785 type->setInfos(this, IT_DualNode, "DualNode", 1, 0, 0);
786 }
787 // DualEdge
788 {
789 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
790 m_types[IT_DualEdge] = type;
791
792 type->setInfos(this, IT_DualEdge, "DualEdge", 1, 0, 0);
793 }
794 // DualFace
795 {
796 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
797 m_types[IT_DualFace] = type;
798
799 type->setInfos(this, IT_DualFace, "DualFace", 1, 0, 0);
800 }
801 // DualCell
802 {
803 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
804 m_types[IT_DualCell] = type;
805
806 type->setInfos(this, IT_DualCell, "DualCell", 1, 0, 0);
807 }
808 // DualParticle
809 {
810 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
811 m_types[IT_DualParticle] = type;
812
813 type->setInfos(this, IT_DualParticle, "DualParticle", 1, 0, 0);
814 }
815 // Link
816 {
817 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
818 m_types[IT_Link] = type;
819
820 type->setInfos(this, IT_Link, "Link", 0, 0, 0);
821 }
822
823 // Enneedron14
824 {
825 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
826 m_types[IT_Enneedron14] = type;
827
828 type->setInfos(this, IT_Enneedron14, "Enneedron14", Dimension::Dim3, 14, 21, 9);
829
830 type->addFaceHeptagon(0, 0, 6, 5, 4, 3, 2, 1);
831 type->addFaceHeptagon(1, 7, 8, 9, 10, 11, 12, 13);
832 type->addFaceQuad(2, 0, 1, 8, 7);
833 type->addFaceQuad(3, 1, 2, 9, 8);
834 type->addFaceQuad(4, 2, 3, 10, 9);
835 type->addFaceQuad(5, 3, 4, 11, 10);
836 type->addFaceQuad(6, 4, 5, 12, 11);
837 type->addFaceQuad(7, 5, 6, 13, 12);
838 type->addFaceQuad(8, 6, 0, 7, 13);
839
840 type->addEdge(0, 0, 1, 2, 0);
841 type->addEdge(1, 1, 2, 3, 0);
842 type->addEdge(2, 2, 3, 4, 0);
843 type->addEdge(3, 3, 4, 5, 0);
844 type->addEdge(4, 4, 5, 6, 0);
845 type->addEdge(5, 5, 6, 7, 0);
846 type->addEdge(6, 6, 0, 8, 0);
847 type->addEdge(7, 7, 8, 1, 2);
848 type->addEdge(8, 8, 9, 1, 3);
849 type->addEdge(9, 9, 10, 1, 4);
850 type->addEdge(10, 10, 11, 1, 5);
851 type->addEdge(11, 11, 12, 1, 6);
852 type->addEdge(12, 12, 13, 1, 7);
853 type->addEdge(13, 13, 7, 1, 8);
854 type->addEdge(14, 0, 7, 8, 2);
855 type->addEdge(15, 1, 8, 1, 2);
856 type->addEdge(16, 2, 9, 2, 3);
857 type->addEdge(17, 3, 10, 3, 4);
858 type->addEdge(18, 4, 11, 4, 5);
859 type->addEdge(19, 5, 12, 5, 6);
860 type->addEdge(20, 6, 13, 6, 7);
861 }
862 // Decaedron16
863 {
864 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
865 m_types[IT_Decaedron16] = type;
866
867 type->setInfos(this, IT_Decaedron16, "Decaedron16", Dimension::Dim3, 16, 24, 10);
868
869 type->addFaceOctogon(0, 0, 7, 6, 5, 4, 3, 2, 1);
870 type->addFaceOctogon(1, 8, 9, 10, 11, 12, 13, 14, 15);
871 type->addFaceQuad(2, 0, 1, 9, 8);
872 type->addFaceQuad(3, 1, 2, 10, 9);
873 type->addFaceQuad(4, 2, 3, 11, 10);
874 type->addFaceQuad(5, 3, 4, 12, 11);
875 type->addFaceQuad(6, 4, 5, 13, 12);
876 type->addFaceQuad(7, 5, 6, 14, 13);
877 type->addFaceQuad(8, 6, 7, 15, 14);
878 type->addFaceQuad(9, 7, 0, 8, 15);
879
880 type->addEdge(0, 0, 1, 2, 0);
881 type->addEdge(1, 1, 2, 3, 0);
882 type->addEdge(2, 2, 3, 4, 0);
883 type->addEdge(3, 3, 4, 5, 0);
884 type->addEdge(4, 4, 5, 6, 0);
885 type->addEdge(5, 5, 6, 7, 0);
886 type->addEdge(6, 6, 7, 8, 0);
887 type->addEdge(7, 7, 0, 9, 0);
888 type->addEdge(8, 8, 9, 1, 2);
889 type->addEdge(9, 9, 10, 1, 3);
890 type->addEdge(10, 10, 11, 1, 4);
891 type->addEdge(11, 11, 12, 1, 5);
892 type->addEdge(12, 12, 13, 1, 6);
893 type->addEdge(13, 13, 14, 1, 7);
894 type->addEdge(14, 14, 15, 1, 8);
895 type->addEdge(15, 15, 8, 1, 9);
896 type->addEdge(16, 0, 8, 9, 2);
897 type->addEdge(17, 1, 9, 2, 3);
898 type->addEdge(18, 2, 10, 3, 4);
899 type->addEdge(19, 3, 11, 4, 5);
900 type->addEdge(20, 4, 12, 5, 6);
901 type->addEdge(21, 5, 13, 6, 7);
902 type->addEdge(22, 6, 14, 7, 8);
903 type->addEdge(23, 7, 15, 8, 9);
904 }
905
906 // Heptagon7
907 {
908 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
909 m_types[IT_Heptagon7] = type;
910
911 type->setInfos(this, IT_Heptagon7, "Heptagon7", Dimension::Dim2, 7, 7, 7);
912
913 type->addEdgeAndFaceLine(0, { 0, 1 }, { 6, 1 });
914 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
915 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
916 type->addEdgeAndFaceLine(3, { 3, 4 }, { 2, 4 });
917 type->addEdgeAndFaceLine(4, { 4, 5 }, { 3, 5 });
918 type->addEdgeAndFaceLine(5, { 5, 6 }, { 4, 6 });
919 type->addEdgeAndFaceLine(6, { 6, 0 }, { 5, 0 });
920 }
921
922 // Octogon8
923 {
924 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
925 m_types[IT_Octogon8] = type;
926
927 type->setInfos(this, IT_Octogon8, "Octogon8", Dimension::Dim2, 8, 8, 8);
928
929 type->addEdgeAndFaceLine(0, { 0, 1 }, { 7, 1 });
930 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
931 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
932 type->addEdgeAndFaceLine(3, { 3, 4 }, { 2, 4 });
933 type->addEdgeAndFaceLine(4, { 4, 5 }, { 3, 5 });
934 type->addEdgeAndFaceLine(5, { 5, 6 }, { 4, 6 });
935 type->addEdgeAndFaceLine(6, { 6, 7 }, { 5, 7 });
936 type->addEdgeAndFaceLine(7, { 7, 0 }, { 6, 0 });
937 }
938
939 // Cell3D_Line2
940 {
941 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
942 m_types[IT_Cell3D_Line2] = type;
943
944 type->setInfos(this, IT_Cell3D_Line2, "Cell3D_Line2", Dimension::Dim1, 2, 0, 0);
945 }
946
947 // CellLine3 (maille d'ordre 2 pour les maillages 1D)
948 {
949 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
950 m_types[IT_CellLine3] = type;
951 type->setOrder(2, ITI_CellLine2);
952
953 type->setInfos(this, IT_CellLine3, "CellLine3", Dimension::Dim1, 3, 0, 2);
954
955 type->addFaceVertex(0, 0);
956 type->addFaceVertex(1, 1);
957 }
958
959 // Cell3D_Line3
960 {
961 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
962 m_types[IT_Cell3D_Line3] = type;
963 type->setOrder(2, ITI_Cell3D_Line2);
964
965 type->setInfos(this, IT_Cell3D_Line3, "Cell3D_Line3", Dimension::Dim1, 3, 0, 0);
966 }
967
968 // Cell3D_Triangle3
969 {
970 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
971 m_types[IT_Cell3D_Triangle3] = type;
972 Int32 nb_face = 3;
973 Int32 nb_edge = 0;
974 if (is_non_manifold)
975 std::swap(nb_face, nb_edge);
976
977 type->setInfos(this, IT_Cell3D_Triangle3, "Cell3D_Triangle3", Dimension::Dim2, 3, nb_edge, nb_face);
978
979 if (is_non_manifold) {
980 type->addEdge2D(0, 0, 1);
981 type->addEdge2D(1, 1, 2);
982 type->addEdge2D(2, 2, 0);
983 }
984 else {
985 type->addFaceLine(0, 0, 1);
986 type->addFaceLine(1, 1, 2);
987 type->addFaceLine(2, 2, 0);
988 }
989 }
990
991 // Cell3D_Triangle6
992 {
993 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
994 m_types[IT_Cell3D_Triangle6] = type;
995 Int32 nb_face = 3;
996 Int32 nb_edge = 0;
997 if (is_non_manifold)
998 std::swap(nb_face, nb_edge);
999
1000 type->setInfos(this, IT_Cell3D_Triangle6, "Cell3D_Triangle6", Dimension::Dim2, 6, nb_edge, nb_face);
1001 type->setOrder(2, ITI_Cell3D_Triangle3);
1002
1003 if (is_non_manifold) {
1004 type->addEdge2D(0, 0, 1);
1005 type->addEdge2D(1, 1, 2);
1006 type->addEdge2D(2, 2, 0);
1007 }
1008 else {
1009 type->addFaceLine3(0, 0, 1, 3);
1010 type->addFaceLine3(1, 1, 2, 4);
1011 type->addFaceLine3(2, 2, 0, 5);
1012 }
1013 }
1014
1015 // Cell3D_Quad4
1016 {
1017 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
1018 m_types[IT_Cell3D_Quad4] = type;
1019 Int32 nb_face = 4;
1020 Int32 nb_edge = 0;
1021 if (is_non_manifold)
1022 std::swap(nb_face, nb_edge);
1023
1024 type->setInfos(this, IT_Cell3D_Quad4, "Cell3D_Quad4", Dimension::Dim2, 4, nb_edge, nb_face);
1025 if (is_non_manifold) {
1026 type->addEdge2D(0, 0, 1);
1027 type->addEdge2D(1, 1, 2);
1028 type->addEdge2D(2, 2, 3);
1029 type->addEdge2D(3, 3, 0);
1030 }
1031 else {
1032 type->addFaceLine(0, 0, 1);
1033 type->addFaceLine(1, 1, 2);
1034 type->addFaceLine(2, 2, 3);
1035 type->addFaceLine(3, 3, 0);
1036 }
1037 }
1038
1039 // Cell3D_Quad8
1040 {
1041 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
1042 m_types[IT_Cell3D_Quad8] = type;
1043
1044 Int32 nb_face = 4;
1045 Int32 nb_edge = 0;
1046 if (is_non_manifold)
1047 std::swap(nb_face, nb_edge);
1048
1049 type->setInfos(this, IT_Cell3D_Quad8, "Cell3D_Quad8", Dimension::Dim2, 8, nb_edge, nb_face);
1050 type->setOrder(2, ITI_Cell3D_Quad4);
1051
1052 if (is_non_manifold) {
1053 type->addEdge2D(0, 0, 1);
1054 type->addEdge2D(1, 1, 2);
1055 type->addEdge2D(2, 2, 3);
1056 type->addEdge2D(3, 3, 0);
1057 }
1058 else {
1059 type->addFaceLine3(0, 0, 1, 4);
1060 type->addFaceLine3(1, 1, 2, 5);
1061 type->addFaceLine3(2, 2, 3, 6);
1062 type->addFaceLine3(3, 3, 0, 7);
1063 }
1064 }
1065
1066 // Cell3D_Quad9
1067 {
1068 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
1069 m_types[IT_Cell3D_Quad9] = type;
1070
1071 Int32 nb_face = 4;
1072 Int32 nb_edge = 0;
1073 if (is_non_manifold)
1074 std::swap(nb_face, nb_edge);
1075
1076 type->setInfos(this, IT_Cell3D_Quad9, "Cell3D_Quad9", Dimension::Dim2, 9, nb_edge, nb_face);
1077 type->setOrder(2, ITI_Cell3D_Quad4);
1078
1079 if (is_non_manifold) {
1080 type->addEdge2D(0, 0, 1);
1081 type->addEdge2D(1, 1, 2);
1082 type->addEdge2D(2, 2, 3);
1083 type->addEdge2D(3, 3, 0);
1084 }
1085 else {
1086 type->addFaceLine3(0, 0, 1, 4);
1087 type->addFaceLine3(1, 1, 2, 5);
1088 type->addFaceLine3(2, 2, 3, 6);
1089 type->addFaceLine3(3, 3, 0, 7);
1090 }
1091 }
1092
1093 { // Polygon & Polyhedron: generic item types
1094 String arcane_item_type_file = platform::getEnvironmentVariable("ARCANE_ITEM_TYPE_FILE");
1095 if (!arcane_item_type_file.null()) {
1096 // verify the existence of item type file. if doesn't exist return an exception
1097 _readTypes(parallel_mng, arcane_item_type_file);
1098 }
1099 }
1100
1101 // Calcul les relations face->arêtes
1102 // Cette opération doit être appelé en fin phase build
1103 for (Integer i = 0; i < m_types.size(); ++i) {
1104 ItemTypeInfoBuilder* type = static_cast<ItemTypeInfoBuilder*>(m_types[i]);
1105 if (!type)
1106 ARCANE_FATAL("ItemType '{0}' is not defined", type);
1107 type->computeFaceEdgeInfos();
1108 }
1109}
1110
1111/*---------------------------------------------------------------------------*/
1112/*---------------------------------------------------------------------------*/
1113
1115printTypes(std::ostream& ostr)
1116{
1117 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1118 Integer nb_type = m_types.size();
1119 ostr << "** Number of types " << nb_type << '\n';
1120 for (Integer i = 0; i < nb_type; ++i) {
1121 ItemTypeInfo* type = m_types[i];
1122 ostr << " - Type " << type->typeId()
1123 << " Name: " << type->typeName()
1124 << " Nodes: " << type->nbLocalNode()
1125 << " Faces " << type->nbLocalFace() << '\n';
1126 for (Integer z = 0, sz = type->nbLocalFace(); z < sz; ++z) {
1127 ItemTypeInfo::LocalFace lf = type->localFace(z);
1128 ostr << " - - Face " << z << ":";
1129 for (Integer zk = 0, szk = lf.nbNode(); zk < szk; ++zk) {
1130 ostr << " " << lf.node(zk);
1131 }
1132 ostr << "\n";
1133 }
1134 ostr << "\n";
1135 }
1136}
1137
1138/*---------------------------------------------------------------------------*/
1139/*---------------------------------------------------------------------------*/
1140/*!
1141 * \brief Lecture d'un fichier de types voronoi.
1142 *
1143 * Une cellule voronoi est un polytope dont le nombre de faces et de noeuds
1144 * varie d'une cellule a l'autre. Ici, le type de chaque cellule est lu dans
1145 * un fichier de types associe a un maillage d'entree donne.
1146 * Ce fichier est passe dans la variable d'environnement: ARCANE_ITEM_TYPE_FILE
1147 * Ex: setenv ARCANE_ITEM_TYPE_FILE PATH_TO_FILE/item_file
1148 * Le format du fichier est la suivante:
1149 *
1150 * nb_type
1151 * type_id nb_faces nb_edges
1152 * nb_node_face0 node0_face0 ... nodeN_face1
1153 * . . .
1154 * . . .
1155 * . . .
1156 * nb_node_faceN node0_faceN ... nodeN_faceN
1157 *
1158 * node0_edge0 node1_edge1 lefFace_edge0 rightFace_edge0
1159 * .
1160 * .
1161 * .
1162 * node0_edgeN node1_edge1 lefFace_edgeN rightFace_edgeN
1163 */
1164void ItemTypeMng::
1165_readTypes(IParallelSuperMng* pm, const String& filename)
1166{
1167 m_trace->info() << "Reading additional item types from file '" << filename << "'";
1168
1169 UniqueArray<Byte> bytes;
1170 Integer size = 0;
1171
1172 // Lecture parallèle
1173 if (pm->commRank() == 0) {
1174 long unsigned int file_length = platform::getFileLength(filename);
1175 if (file_length == 0)
1176 throw IOException(A_FUNCINFO, "ARCANE_ITEM_TYPE_FILE is an empty file");
1177 std::ifstream ifile;
1178 ifile.open(filename.localstr(), std::ios::binary);
1179 if (ifile.fail())
1180 throw IOException(A_FUNCINFO, "Cannot open ARCANE_ITEM_TYPE_FILE item type file");
1181 bytes.resize(arcaneCheckArraySize(file_length + 1));
1182 ifile.read((char*)bytes.data(), file_length);
1183 bytes[(Integer)file_length] = '\0';
1184 if (ifile.bad())
1185 throw IOException(A_FUNCINFO, "Cannot read ARCANE_ITEM_TYPE_FILE item type file");
1186 size = bytes.size();
1187 }
1188 {
1189 IntegerArrayView bs(1, &size);
1190 pm->broadcast(bs, 0);
1191 }
1192 bytes.resize(size);
1193 if (size != 0) {
1194 pm->broadcast(bytes, 0);
1195 }
1196 else { // CC: add ending '\0'
1197 bytes.resize(1);
1198 bytes[0] = '\0';
1199 }
1200
1201 // Already built polygons (size => identifier)
1202 typedef std::map<Integer, Integer> PolygonMapper;
1203 PolygonMapper built_polygons;
1204 built_polygons[3] = IT_Triangle3;
1205 built_polygons[4] = IT_Quad4;
1206 built_polygons[5] = IT_Pentagon5;
1207 built_polygons[6] = IT_Hexagon6;
1208 typedef std::set<Integer> KnownTypes;
1209 KnownTypes known_types;
1210 for (Integer i_type = 0; i_type < ItemTypeMng::nbBuiltInItemType(); ++i_type)
1211 known_types.insert(i_type);
1212
1213 if (ItemTypeMng::nbBuiltInItemType() != m_types.size())
1214 throw FatalErrorException(A_FUNCINFO, "Invalid initialization of built-in item types");
1215
1216 // Analyse du fichier de types
1217 std::istringstream ifile((char*)bytes.unguardedBasePointer(), std::istringstream::in);
1218 Integer nb_type = 0;
1219 ifile >> nb_type;
1220
1221 m_types.resize(ItemTypeMng::nbBuiltInItemType() + nb_type);
1222 Int16 typeId = -1, nbN = 0, nbE = 0, nbF = 0;
1223 for (Integer i = 0; i < nb_type; ++i) {
1224 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
1225 ifile >> typeId >> nbF >> nbE;
1226 if (typeId >= nb_type || typeId < 0)
1227 throw IOException(A_FUNCINFO, String::format("Polyhedron reader cannot allow typeId {0}", typeId));
1228 typeId += ItemTypeMng::nbBuiltInItemType(); // translation d'indexation
1229 if (known_types.find(typeId) != known_types.end())
1230 throw FatalErrorException(A_FUNCINFO, String::format("Already existing typeId {0}", typeId));
1231 known_types.insert(typeId);
1232 if (nbE == nbF) // 2d case nbN == nbE == nbF
1233 {
1234 nbN = nbE;
1235 }
1236 else
1237 nbN = nbE - nbF + 2; // Calcul du nb de noeuds nbN a partir de nbE et nbF (formule d'Euler)
1238
1239 type->setInfos(this, typeId, String::format("Polyhedron{0}_{1}-{2}-{3}", typeId, nbN, nbE, nbF), nbN, nbE, nbF);
1240 m_trace->debug(Trace::High) << "Adding " << type->typeName() << " type #"
1241 << typeId - ItemTypeMng::nbBuiltInItemType() << " with " << nbN << " nodes, "
1242 << nbE << " edges, " << nbF << " faces.";
1243 m_types[typeId] = type;
1244 for (Integer iface = 0; iface < nbF; ++iface) {
1245 ifile >> nbN;
1246 UniqueArray<Integer> nodeFace(nbN);
1247 for (Integer inodeFace = 0; inodeFace < nbN; ++inodeFace) {
1248 ifile >> nodeFace[inodeFace];
1249 }
1250 PolygonMapper::const_iterator finder = built_polygons.find(nbN);
1251 Int16 face_type = IT_NullType;
1252 if (finder != built_polygons.end()) {
1253 face_type = finder->second;
1254 m_trace->debug(Trace::High) << "\tAdding already existing face type " << face_type
1255 << " for face " << iface << " with " << nbN << " nodes";
1256 }
1257 else {
1258 ItemTypeInfoBuilder* type2 = m_types_buffer->allocOne();
1259
1260 face_type = m_types.size();
1261 m_types.add(type2);
1262 built_polygons[nbN] = face_type;
1263
1264 type2->setInfos(this, face_type, String::format("Polygon{0}", nbN), nbN, nbN, nbN);
1265 for (Integer j = 0; j < nbN; ++j)
1266 type2->addFaceLine(j, j, (j + 1) % nbN);
1267
1268 for (Integer j = 0; j < nbN; ++j)
1269 type2->addEdge(j, j, (j + 1) % nbN, (j - 1 + nbN) % nbN, (j + 1) % nbN);
1270 m_trace->debug(Trace::High) << "\tAdding new face type " << face_type
1271 << " for face " << iface << " with " << nbN << " nodes";
1272 }
1273 type->addFaceGeneric(iface, face_type, nodeFace);
1274 }
1275 Integer node0, node1, leftFace, rightFace;
1276 for (Integer iedge = 0; iedge < nbE; ++iedge) {
1277 ifile >> node0 >> node1 >> leftFace >> rightFace;
1278 type->addEdge(iedge, node0, node1, leftFace, rightFace);
1279 }
1280 }
1281
1282 m_trace->debug(Trace::High) << "Total number of types : " << m_types.size();
1283}
1284
1285/*---------------------------------------------------------------------------*/
1286/*---------------------------------------------------------------------------*/
1287
1290{
1291 return _singleton()->types().size();
1292}
1293
1296{
1297 return m_nb_builtin_item_type;
1298}
1299/*---------------------------------------------------------------------------*/
1300/*---------------------------------------------------------------------------*/
1301
1302//! AMR
1305{
1306 switch (type) {
1307 case IT_Line2:
1308 return 2;
1309 case IT_Triangle3:
1310 return 4;
1311 case IT_Quad4:
1312 return 4;
1313 case IT_Pentagon5:
1314 return 4;
1315 case IT_Hexagon6:
1316 return 4;
1317 case IT_Tetraedron4:
1318 return 8;
1319 case IT_Pyramid5:
1320 return 0;
1321 case IT_Pentaedron6:
1322 return 8;
1323 case IT_Hexaedron8:
1324 return 8;
1325 case IT_Heptaedron10:
1326 case IT_Octaedron12:
1327 case IT_HemiHexa7:
1328 case IT_HemiHexa6:
1329 case IT_HemiHexa5:
1330 case IT_AntiWedgeLeft6:
1331 case IT_AntiWedgeRight6:
1332 case IT_DiTetra5:
1333 return 0;
1334 default:
1335 ARCANE_FATAL("Not supported Item Type '{0}'", type);
1336 }
1337}
1338
1339/*---------------------------------------------------------------------------*/
1340/*---------------------------------------------------------------------------*/
1341
1342ItemTypeMng* ItemTypeMng::singleton_instance = 0;
1343
1344ItemTypeMng* ItemTypeMng::
1345_singleton()
1346{
1347 if (!singleton_instance)
1348 singleton_instance = new ItemTypeMng();
1349 return singleton_instance;
1350}
1351
1352void ItemTypeMng::
1353_destroySingleton()
1354{
1355 //GG: Ca plante avec Windows. Regarder pourquoi.
1356#ifndef ARCANE_OS_WIN32
1357 delete singleton_instance;
1358#endif
1359 singleton_instance = nullptr;
1360}
1361
1362/*---------------------------------------------------------------------------*/
1363/*---------------------------------------------------------------------------*/
1364
1366types() const
1367{
1368 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1369 return m_types;
1370}
1371
1372/*---------------------------------------------------------------------------*/
1373/*---------------------------------------------------------------------------*/
1374
1375ItemTypeInfo* ItemTypeMng::
1376typeFromId(Integer id) const
1377{
1378 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1379 return m_types[id];
1380}
1381
1382/*---------------------------------------------------------------------------*/
1383/*---------------------------------------------------------------------------*/
1384
1385ItemTypeInfo* ItemTypeMng::
1386typeFromId(ItemTypeId id) const
1387{
1388 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1389 return m_types[id.typeId()];
1390}
1391
1392/*---------------------------------------------------------------------------*/
1393/*---------------------------------------------------------------------------*/
1394
1396typeName(Integer id) const
1397{
1398 return typeFromId(id)->typeName();
1399}
1400
1401/*---------------------------------------------------------------------------*/
1402/*---------------------------------------------------------------------------*/
1403
1405typeName(ItemTypeId id) const
1406{
1407 return typeFromId(id)->typeName();
1408}
1409
1410/*---------------------------------------------------------------------------*/
1411/*---------------------------------------------------------------------------*/
1412// Recopie de la fonction obsolète Item::typeName().
1413// TODO: voir pourquoi il y a un test sur nBasicItemType().
1414String ItemTypeMng::
1415_legacyTypeName(Integer t)
1416{
1417 if (t >= 0 && t < nbBasicItemType())
1418 return _singleton()->typeFromId(t)->typeName();
1419 return "InvalidType";
1420}
1421
1422/*---------------------------------------------------------------------------*/
1423/*---------------------------------------------------------------------------*/
1424
1426{
1427 auto has_general_cells = false;
1428 if (m_mesh_with_general_cells.find(mesh) != m_mesh_with_general_cells.end()) {
1429 has_general_cells = true;
1430 }
1431 return has_general_cells;
1432}
1433
1434/*---------------------------------------------------------------------------*/
1435/*---------------------------------------------------------------------------*/
1436
1438{
1439 ARCANE_ASSERT(mesh, ("Trying to indicate a null mesh contains general cells."));
1440 m_mesh_with_general_cells.insert(mesh);
1441}
1442
1443/*---------------------------------------------------------------------------*/
1444/*---------------------------------------------------------------------------*/
1445
1446} // End namespace Arcane
1447
1448/*---------------------------------------------------------------------------*/
1449/*---------------------------------------------------------------------------*/
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Integer size() const
Nombre d'éléments du vecteur.
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
const T * data() const
Accès à la racine du tableau hors toute protection.
Vue constante d'un tableau de type T.
virtual IParallelSuperMng * parallelSuperMng()=0
Gestionnaire superviseur du parallélisme.
Exception lorsqu'une erreur d'entrée/sortie est détectée.
Definition IOException.h:32
virtual void broadcast(ByteArrayView send_buf, Integer process_id)=0
Envoie un tableau de valeurs sur tous les processus Cette opération synchronise le tableau de valeur ...
virtual Int32 commRank() const =0
Retourne le numéro du process (compris entre 0 et nbProcess()-1)
virtual IApplication * application() const =0
Retourne le gestionnaire principal.
virtual Int32 commSize() const =0
Retourne le nombre total de process utilisés.
Interface du gestionnaire de traces.
virtual TraceMessage info()=0
Flot pour un message d'information.
Type d'une entité (Item).
Definition ItemTypeId.h:32
Informations locales sur une face d'une maille.
Integer node(Integer i) const
Indice locale dans la maille du i-ème noeud de la face.
Integer nbNode() const
Nombre de noeuds de la face.
LocalFace localFace(Integer id) const
Connectivité locale de la i-ème face de la maille.
Integer nbLocalNode() const
Nombre de noeuds de l'entité
String typeName() const
Nom du type.
Integer nbLocalFace() const
Nombre de faces de l'entité
Int16 typeId() const
Numéro du type.
Gestionnaire des types d'entités d'un maillage.
Definition ItemTypeMng.h:65
void setMeshWithGeneralCells(IMesh *mesh) noexcept
Permet au maillage d'indiquer à l'ItemTypeMng s'il a des mailles génériques.
bool hasGeneralCells(IMesh *mesh) const
Indique si le maillage mesh contient des mailles génériques (en dehors des types intégrés ou addition...
ItemTypeMng()
Constructeur vide (non initialisé)
static Int32 nbHChildrenByItemType(Integer type)
AMR.
static Integer nbBasicItemType()
nombre de types disponibles
ItemTypeInfo * typeFromId(Integer id) const
Type correspondant au numéro id.
void build(IParallelSuperMng *parallel_mng, ITraceMng *trace)
Constructeur effectif.
ConstArrayView< ItemTypeInfo * > types() const
Liste des types disponibles.
static Integer nbBuiltInItemType()
nombre de types intégrés (hors types additionnels)
void printTypes(std::ostream &ostr)
Affiche les infos sur les types disponibles sur le flot ostr.
String typeName(Integer id) const
Nom du type correspondant au numéro id.
Chaîne de caractères unicode.
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:228
Vecteur 1D de données avec sémantique par valeur (style STL).
ARCCORE_BASE_EXPORT long unsigned int getFileLength(const String &filename)
Longueur du fichier filename. Si le fichier n'est pas lisible ou n'existe pas, retourne 0.
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
Int32 Integer
Type représentant un entier.
ArrayView< Integer > IntegerArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:544
std::int16_t Int16
Type entier signé sur 16 bits.
std::int32_t Int32
Type entier signé sur 32 bits.