Arcane  v3.16.2.0
Documentation développeur
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 "arcane/utils/Iostream.h"
17#include "arcane/utils/String.h"
18#include "arcane/utils/PlatformUtils.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/TraceAccessor.h"
21#include "arcane/utils/IStackTraceService.h"
22#include "arcane/utils/IOException.h"
23#include "arcane/utils/FatalErrorException.h"
24#include "arcane/utils/Array.h"
25#include "arcane/utils/MultiBuffer.h"
26
27#include "arcane/core/ItemTypeInfoBuilder.h"
28#include "arcane/core/IParallelSuperMng.h"
29#include "arcane/core/ItemTypeInfoBuilder.h"
30#include "arcane/core/IMesh.h"
31#include "arcane/core/MeshKind.h"
32#include "arcane/core/ISubDomain.h"
33#include "arcane/core/IApplication.h"
34
35// AMR
36#include "arcane/ItemRefinementPattern.h"
37
38#include <map>
39#include <set>
40
41/*---------------------------------------------------------------------------*/
42/*---------------------------------------------------------------------------*/
43
44namespace Arcane
45{
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49
50const Integer ItemTypeMng::m_nb_builtin_item_type = NB_BASIC_ITEM_TYPE;
51
52/*---------------------------------------------------------------------------*/
53/*---------------------------------------------------------------------------*/
54
59
60/*---------------------------------------------------------------------------*/
61/*---------------------------------------------------------------------------*/
62
63ItemTypeMng::
64~ItemTypeMng()
65{
66 delete m_types_buffer;
67}
68
69/*---------------------------------------------------------------------------*/
70/*---------------------------------------------------------------------------*/
71
74{
75 if (m_initialized)
76 ARCANE_FATAL("ItemTypeMng instance is already initialized");
77 // Récupère le IParallelSuperMng via l'application.
78 // Une fois qu'on aura supprimé l'instance singleton, on pourra
79 // simplement utiliser le IParallelMng.
80 IParallelSuperMng* super_pm = mesh->subDomain()->application()->parallelSuperMng();
81 _buildTypes(mesh, super_pm, mesh->traceMng());
82 m_initialized = true;
83}
84
85/*---------------------------------------------------------------------------*/
86/*---------------------------------------------------------------------------*/
87
89build(IParallelSuperMng* parallel_mng, ITraceMng* trace)
90{
91 _buildSingleton(parallel_mng, trace);
92}
93
94/*---------------------------------------------------------------------------*/
95/*---------------------------------------------------------------------------*/
96
97void ItemTypeMng::
98_buildSingleton(IParallelSuperMng* parallel_mng, ITraceMng* trace)
99{
100 // Avec MPC, cette fonction peut être appelée plusieurs fois
101 // dans des threads différents. Comme tous les threads partagent
102 // le même singleton, seul le premier thread fait réellement l'initialisation.
103 // ATTENTION: Cela est incompatible avec le mode readTypes()
104 // ou on lit les connectivités dans un fichier ARCANE_ITEM_TYPE_FILE.
105 Int32 max_rank = parallel_mng->commSize() + 1;
106 Int32 init_counter = ++m_initialized_counter;
107 if (init_counter == 1) {
108 _buildTypes(nullptr, parallel_mng, trace);
109 m_initialized = true;
110 m_initialized_counter = max_rank;
111 }
112 else
113 // Ceux qui ne font pas l'initialisation doivent attendre que cette dernière
114 // soit faite.
115 while (init_counter < max_rank)
116 init_counter = m_initialized_counter.load();
117}
118
119/*---------------------------------------------------------------------------*/
120/*---------------------------------------------------------------------------*/
127_buildTypes(IMesh* mesh, IParallelSuperMng* parallel_mng, ITraceMng* trace)
128{
129 // Construit la connectivité des éléments.
130 // Pour les éléments classiques, la connectivité est la même que
131 // celle de VTK, disponible dans le document:
132 //
133 // https://vtk.org/wp-content/uploads/2015/04/file-formats.pdf
134
135 using Dimension = ItemTypeInfoBuilder::Dimension;
136 bool is_non_manifold = false;
137 if (mesh)
138 is_non_manifold = mesh->meshKind().isNonManifold();
139
140 m_trace = trace;
143
144 // Null
145 {
146 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
147 m_types[IT_NullType] = type;
148
149 type->setInfos(this, IT_NullType, "NullType", Dimension::DimUnknown, 0, 0, 0);
150 }
151
152 // Vertex
153 {
154 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
155 m_types[IT_Vertex] = type;
156
157 type->setInfos(this, IT_Vertex, "Vertex", Dimension::Dim0, 0, 0, 0);
158 // TODO regarder si ce type est autorisé pour les mailles.
159 // Si ce n'est pas le cas, il faudrait définir un type
160 // pour les mailles 0D qui sont assimilables à des points.
161 }
162
163 // FaceVertex (face pour les maillages 1D)
164 {
165 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
166 m_types[IT_FaceVertex] = type;
167
168 type->setInfos(this, IT_FaceVertex, "FaceVertex", Dimension::Dim0, 1, 0, 0);
169 type->setIsValidForCell(false);
170 }
171
172 // Line2
173 {
174 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
175 m_types[IT_Line2] = type;
176
177 type->setInfos(this, IT_Line2, "Line2", Dimension::Dim1, 2, 0, 0);
178 type->setIsValidForCell(true);
179 }
180
181 // Line3
182 {
183 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
184 m_types[IT_Line3] = type;
185 type->setOrder(2, ITI_Line2);
186
187 type->setInfos(this, IT_Line3, "Line3", Dimension::Dim1, 3, 0, 0);
188 type->setIsValidForCell(false);
189 }
190
191 // CellLine2 (mailles pour les maillages 1D)
192 {
193 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
194 m_types[IT_CellLine2] = type;
195
196 type->setInfos(this, IT_CellLine2, "CellLine2", Dimension::Dim1, 2, 0, 2);
197
198 type->addFaceVertex(0, 0);
199 type->addFaceVertex(1, 1);
200 }
201
208
209 // Triangle3
210 {
211 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
212 m_types[IT_Triangle3] = type;
213
214 type->setInfos(this, IT_Triangle3, "Triangle3", Dimension::Dim2, 3, 3, 3);
215
216 type->addEdgeAndFaceLine(0, { 0, 1 }, { 1, 2 });
217 type->addEdgeAndFaceLine(1, { 1, 2 }, { 2, 0 });
218 type->addEdgeAndFaceLine(2, { 2, 0 }, { 0, 1 });
219 }
220
221 // Triangle6
222 {
223 // TODO: Pour l'instant comme triangle3
224 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
225 m_types[IT_Triangle6] = type;
226
227 type->setInfos(this, IT_Triangle6, "Triangle6", Dimension::Dim2, 6, 3, 3);
228 type->setOrder(2, ITI_Triangle3);
229
230 type->addFaceLine3(0, 0, 1, 3);
231 type->addFaceLine3(1, 1, 2, 4);
232 type->addFaceLine3(2, 2, 0, 5);
233
234 type->addEdge(0, 0, 1, 1, 2);
235 type->addEdge(1, 1, 2, 2, 0);
236 type->addEdge(2, 2, 0, 0, 1);
237 }
238
239 // Quad4
240 {
241 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
242 m_types[IT_Quad4] = type;
243
244 type->setInfos(this, IT_Quad4, "Quad4", Dimension::Dim2, 4, 4, 4);
245
246 type->addEdgeAndFaceLine(0, { 0, 1 }, { 3, 1 });
247 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
248 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
249 type->addEdgeAndFaceLine(3, { 3, 0 }, { 2, 0 });
250 }
251
252 // Quad8
253 {
254 // TODO: Pour l'instant comme quad4
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 // Pentagon5
273 {
274 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
275 m_types[IT_Pentagon5] = type;
276
277 type->setInfos(this, IT_Pentagon5, "Pentagon5", Dimension::Dim2, 5, 5, 5);
278
279 type->addFaceLine(0, 0, 1);
280 type->addFaceLine(1, 1, 2);
281 type->addFaceLine(2, 2, 3);
282 type->addFaceLine(3, 3, 4);
283 type->addFaceLine(4, 4, 0);
284
285 type->addEdge(0, 0, 1, 4, 1);
286 type->addEdge(1, 1, 2, 0, 2);
287 type->addEdge(2, 2, 3, 1, 3);
288 type->addEdge(3, 3, 4, 2, 4);
289 type->addEdge(4, 4, 0, 3, 0);
290 }
291
292 // Hexagon6
293 {
294 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
295 m_types[IT_Hexagon6] = type;
296
297 type->setInfos(this, IT_Hexagon6, "Hexagon6", Dimension::Dim2, 6, 6, 6);
298
299 type->addFaceLine(0, 0, 1);
300 type->addFaceLine(1, 1, 2);
301 type->addFaceLine(2, 2, 3);
302 type->addFaceLine(3, 3, 4);
303 type->addFaceLine(4, 4, 5);
304 type->addFaceLine(5, 5, 0);
305
306 type->addEdge(0, 0, 1, 5, 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, 5, 3, 5);
311 type->addEdge(5, 5, 0, 4, 0);
312 }
313
314 // Hexaedron8
315 {
316 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
317 m_types[IT_Hexaedron8] = type;
318
319 type->setInfos(this, IT_Hexaedron8, "Hexaedron8", Dimension::Dim3, 8, 12, 6);
320
321 type->addFaceQuad(0, 0, 3, 2, 1);
322 type->addFaceQuad(1, 0, 4, 7, 3);
323 type->addFaceQuad(2, 0, 1, 5, 4);
324 type->addFaceQuad(3, 4, 5, 6, 7);
325 type->addFaceQuad(4, 1, 2, 6, 5);
326 type->addFaceQuad(5, 2, 3, 7, 6);
327
328 type->addEdge(0, 0, 1, 2, 0);
329 type->addEdge(1, 1, 2, 4, 0);
330 type->addEdge(2, 2, 3, 5, 0);
331 type->addEdge(3, 3, 0, 1, 0);
332 type->addEdge(4, 0, 4, 1, 2);
333 type->addEdge(5, 1, 5, 2, 4);
334 type->addEdge(6, 2, 6, 4, 5);
335 type->addEdge(7, 3, 7, 5, 1);
336 type->addEdge(8, 4, 5, 3, 2);
337 type->addEdge(9, 5, 6, 3, 4);
338 type->addEdge(10, 6, 7, 3, 5);
339 type->addEdge(11, 7, 4, 3, 1);
340 }
341
342 // Hexaedron20
343 {
344 // Pour l'instant comme Hexaedron8
345 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
346 m_types[IT_Hexaedron20] = type;
347
348 type->setInfos(this, IT_Hexaedron20, "Hexaedron20", Dimension::Dim3, 20, 12, 6);
349 type->setOrder(2, ITI_Hexaedron8);
350
351 type->addFaceQuad8(0, 0, 3, 2, 1, 11, 10, 9, 8);
352 type->addFaceQuad8(1, 0, 4, 7, 3, 16, 15, 19, 11);
353 type->addFaceQuad8(2, 0, 1, 5, 4, 8, 17, 12, 16);
354 type->addFaceQuad8(3, 4, 5, 6, 7, 12, 13, 14, 15);
355 type->addFaceQuad8(4, 1, 2, 6, 5, 9, 18, 13, 17);
356 type->addFaceQuad8(5, 2, 3, 7, 6, 10, 19, 14, 18);
357
358 type->addEdge(0, 0, 1, 2, 0);
359 type->addEdge(1, 1, 2, 4, 0);
360 type->addEdge(2, 2, 3, 5, 0);
361 type->addEdge(3, 3, 0, 1, 0);
362 type->addEdge(4, 0, 4, 1, 2);
363 type->addEdge(5, 1, 5, 2, 4);
364 type->addEdge(6, 2, 6, 4, 5);
365 type->addEdge(7, 3, 7, 5, 1);
366 type->addEdge(8, 4, 5, 3, 2);
367 type->addEdge(9, 5, 6, 3, 4);
368 type->addEdge(10, 6, 7, 3, 5);
369 type->addEdge(11, 7, 4, 3, 1);
370 }
371
372 // Pyramid5
373 {
374 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
375 m_types[IT_Pyramid5] = type;
376
377 type->setInfos(this, IT_Pyramid5, "Pyramid5", Dimension::Dim3, 5, 8, 5);
378
379 type->addFaceQuad(0, 0, 3, 2, 1);
380 type->addFaceTriangle(1, 0, 4, 3);
381 type->addFaceTriangle(2, 0, 1, 4);
382 type->addFaceTriangle(3, 1, 2, 4);
383 type->addFaceTriangle(4, 2, 3, 4);
384
385 type->addEdge(0, 0, 1, 2, 0);
386 type->addEdge(1, 1, 2, 3, 0);
387 type->addEdge(2, 2, 3, 4, 0);
388 type->addEdge(3, 3, 0, 1, 0);
389 type->addEdge(4, 0, 4, 1, 2);
390 type->addEdge(5, 1, 4, 2, 3);
391 type->addEdge(6, 2, 4, 3, 4);
392 type->addEdge(7, 3, 4, 4, 1);
393 }
394
395 // Pentaedron6
396 {
397 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
398 m_types[IT_Pentaedron6] = type;
399
400 type->setInfos(this, IT_Pentaedron6, "Pentaedron6", Dimension::Dim3, 6, 9, 5);
401
402 type->addFaceTriangle(0, 0, 2, 1);
403 type->addFaceQuad(1, 0, 3, 5, 2);
404 type->addFaceQuad(2, 0, 1, 4, 3);
405 type->addFaceTriangle(3, 3, 4, 5);
406 type->addFaceQuad(4, 1, 2, 5, 4);
407
408 type->addEdge(0, 0, 1, 2, 0);
409 type->addEdge(1, 1, 2, 4, 0);
410 type->addEdge(2, 2, 0, 1, 0);
411 type->addEdge(3, 0, 3, 1, 2);
412 type->addEdge(4, 1, 4, 2, 4);
413 type->addEdge(5, 2, 5, 4, 1);
414 type->addEdge(6, 3, 4, 3, 2);
415 type->addEdge(7, 4, 5, 3, 4);
416 type->addEdge(8, 5, 3, 3, 1);
417 }
418
419 // Tetraedron4
420 {
421 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
422 m_types[IT_Tetraedron4] = type;
423
424 type->setInfos(this, IT_Tetraedron4, "Tetraedron4", Dimension::Dim3, 4, 6, 4);
425
426 type->addFaceTriangle(0, 0, 2, 1);
427 type->addFaceTriangle(1, 0, 3, 2);
428 type->addFaceTriangle(2, 0, 1, 3);
429 type->addFaceTriangle(3, 1, 2, 3);
430
431 type->addEdge(0, 0, 1, 2, 0);
432 type->addEdge(1, 1, 2, 3, 0);
433 type->addEdge(2, 2, 0, 1, 0);
434 type->addEdge(3, 0, 3, 1, 2);
435 type->addEdge(4, 1, 3, 2, 3);
436 type->addEdge(5, 2, 3, 3, 1);
437 }
438
439 // Tetraedron10
440 {
441 // Pour l'instant comme Tetraedron4
442 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
443 m_types[IT_Tetraedron10] = type;
444
445 type->setInfos(this, IT_Tetraedron10, "Tetraedron10", Dimension::Dim3, 10, 6, 4);
446 type->setOrder(2, ITI_Tetraedron4);
447
448 type->addFaceTriangle6(0, 0, 2, 1, 6, 5, 4);
449 type->addFaceTriangle6(1, 0, 3, 2, 7, 9, 6);
450 type->addFaceTriangle6(2, 0, 1, 3, 4, 8, 7);
451 type->addFaceTriangle6(3, 1, 2, 3, 5, 9, 8);
452
453 type->addEdge(0, 0, 1, 2, 0);
454 type->addEdge(1, 1, 2, 3, 0);
455 type->addEdge(2, 2, 0, 1, 0);
456 type->addEdge(3, 0, 3, 1, 2);
457 type->addEdge(4, 1, 3, 2, 3);
458 type->addEdge(5, 2, 3, 3, 1);
459 }
460
461 // Heptaedron10
462 {
463 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
464 m_types[IT_Heptaedron10] = type;
465
466 type->setInfos(this, IT_Heptaedron10, "Heptaedron10", Dimension::Dim3, 10, 15, 7);
467
468 type->addFacePentagon(0, 0, 4, 3, 2, 1);
469 type->addFacePentagon(1, 5, 6, 7, 8, 9);
470 type->addFaceQuad(2, 0, 1, 6, 5);
471 type->addFaceQuad(3, 1, 2, 7, 6);
472 type->addFaceQuad(4, 2, 3, 8, 7);
473 type->addFaceQuad(5, 3, 4, 9, 8);
474 type->addFaceQuad(6, 4, 0, 5, 9);
475
476 type->addEdge(0, 0, 1, 2, 0);
477 type->addEdge(1, 1, 2, 3, 0);
478 type->addEdge(2, 2, 3, 4, 0);
479 type->addEdge(3, 3, 4, 5, 0);
480 type->addEdge(4, 4, 0, 6, 0);
481 type->addEdge(5, 5, 6, 1, 2);
482 type->addEdge(6, 6, 7, 1, 3);
483 type->addEdge(7, 7, 8, 1, 4);
484 type->addEdge(8, 8, 9, 1, 5);
485 type->addEdge(9, 9, 5, 1, 6);
486 type->addEdge(10, 0, 5, 6, 2);
487 type->addEdge(11, 1, 6, 2, 3);
488 type->addEdge(12, 2, 7, 3, 4);
489 type->addEdge(13, 3, 8, 4, 5);
490 type->addEdge(14, 4, 9, 5, 6);
491 }
492
493 // Octaedron12
494 {
495 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
496 m_types[IT_Octaedron12] = type;
497
498 type->setInfos(this, IT_Octaedron12, "Octaedron12", Dimension::Dim3, 12, 18, 8);
499
500 type->addFaceHexagon(0, 0, 5, 4, 3, 2, 1);
501 type->addFaceHexagon(1, 6, 7, 8, 9, 10, 11);
502 type->addFaceQuad(2, 0, 1, 7, 6);
503 type->addFaceQuad(3, 1, 2, 8, 7);
504 type->addFaceQuad(4, 2, 3, 9, 8);
505 type->addFaceQuad(5, 3, 4, 10, 9);
506 type->addFaceQuad(6, 4, 5, 11, 10);
507 type->addFaceQuad(7, 5, 0, 6, 11);
508
509 type->addEdge(0, 0, 1, 2, 0);
510 type->addEdge(1, 1, 2, 3, 0);
511 type->addEdge(2, 2, 3, 4, 0);
512 type->addEdge(3, 3, 4, 5, 0);
513 type->addEdge(4, 4, 5, 6, 0);
514 type->addEdge(5, 5, 0, 7, 0);
515 type->addEdge(6, 6, 7, 1, 2);
516 type->addEdge(7, 7, 8, 1, 3);
517 type->addEdge(8, 8, 9, 1, 4);
518 type->addEdge(9, 9, 10, 1, 5);
519 type->addEdge(10, 10, 11, 1, 6);
520 type->addEdge(11, 11, 6, 1, 7);
521 type->addEdge(12, 0, 6, 7, 2);
522 type->addEdge(13, 1, 7, 2, 3);
523 type->addEdge(14, 2, 8, 3, 4);
524 type->addEdge(15, 3, 9, 4, 5);
525 type->addEdge(16, 4, 10, 5, 6);
526 type->addEdge(17, 5, 11, 6, 7);
527 }
528
529 // HemiHexa7
530 {
531 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
532 m_types[IT_HemiHexa7] = type;
533
534 type->setInfos(this, IT_HemiHexa7, "HemiHexa7", Dimension::Dim3, 7, 11, 6);
535
536 type->addFaceTriangle(0, 0, 1, 2);
537 type->addFaceQuad(1, 0, 2, 3, 4);
538 type->addFaceQuad(2, 0, 5, 6, 1);
539 type->addFaceTriangle(3, 0, 4, 5);
540 type->addFaceQuad(4, 1, 6, 3, 2);
541 type->addFaceQuad(5, 3, 6, 5, 4);
542
543 type->addEdge(0, 0, 1, 0, 2);
544 type->addEdge(1, 1, 2, 0, 4);
545 type->addEdge(2, 2, 0, 0, 1);
546 type->addEdge(3, 2, 3, 1, 4);
547 type->addEdge(4, 3, 4, 1, 5);
548 type->addEdge(5, 4, 5, 3, 5);
549 type->addEdge(6, 5, 0, 3, 2);
550 type->addEdge(7, 0, 4, 3, 1);
551 type->addEdge(8, 5, 6, 2, 5);
552 type->addEdge(9, 6, 1, 2, 4);
553 type->addEdge(10, 3, 6, 5, 4);
554 }
555
556 // HemiHexa6
557 {
558 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
559 m_types[IT_HemiHexa6] = type;
560
561 type->setInfos(this, IT_HemiHexa6, "HemiHexa6", Dimension::Dim3, 6, 10, 6);
562
563 type->addFaceTriangle(0, 0, 1, 2);
564 type->addFaceQuad(1, 0, 2, 3, 4);
565 type->addFaceQuad(2, 0, 5, 3, 1);
566 type->addFaceTriangle(3, 0, 4, 5);
567 type->addFaceTriangle(4, 1, 3, 2);
568 type->addFaceTriangle(5, 3, 5, 4);
569
570 type->addEdge(0, 0, 1, 0, 2);
571 type->addEdge(1, 1, 2, 0, 4);
572 type->addEdge(2, 2, 0, 0, 1);
573 type->addEdge(3, 2, 3, 1, 4);
574 type->addEdge(4, 3, 4, 1, 5);
575 type->addEdge(5, 4, 5, 3, 5);
576 type->addEdge(6, 5, 0, 3, 2);
577 type->addEdge(7, 0, 4, 3, 1);
578 type->addEdge(8, 5, 3, 2, 5);
579 type->addEdge(9, 3, 1, 2, 4);
580 }
581
582 // HemiHexa5
583 {
584 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
585 m_types[IT_HemiHexa5] = type;
586
587 type->setInfos(this, IT_HemiHexa5, "HemiHexa5", Dimension::Dim3, 5, 7, 4);
588
589 type->addFaceTriangle(0, 0, 1, 2);
590 type->addFaceQuad(1, 0, 2, 3, 4);
591 type->addFaceQuad(2, 0, 4, 3, 1);
592 type->addFaceTriangle(3, 1, 3, 2);
593
594 type->addEdge(0, 0, 1, 0, 2);
595 type->addEdge(1, 1, 2, 0, 3);
596 type->addEdge(2, 2, 0, 0, 1);
597 type->addEdge(3, 2, 3, 1, 3);
598 type->addEdge(4, 3, 1, 2, 3);
599 type->addEdge(5, 3, 4, 1, 2);
600 type->addEdge(6, 4, 0, 1, 2);
601 }
602
603 // AntiWedgeLeft6
604 {
605 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
606 m_types[IT_AntiWedgeLeft6] = type;
607
608 type->setInfos(this, IT_AntiWedgeLeft6, "AntiWedgeLeft6", Dimension::Dim3, 6, 10, 6);
609
610 type->addFaceTriangle(0, 0, 2, 1);
611 type->addFaceQuad(1, 0, 3, 5, 2);
612 type->addFaceQuad(2, 0, 1, 4, 3);
613 type->addFaceTriangle(3, 3, 4, 5);
614 type->addFaceTriangle(4, 1, 2, 4);
615 type->addFaceTriangle(5, 2, 5, 4);
616
617 type->addEdge(0, 0, 1, 0, 2);
618 type->addEdge(1, 1, 2, 4, 0);
619 type->addEdge(2, 2, 0, 1, 0);
620 type->addEdge(3, 0, 3, 1, 2);
621 type->addEdge(4, 1, 4, 2, 4);
622 type->addEdge(5, 2, 5, 5, 1);
623 type->addEdge(6, 3, 4, 3, 2);
624 type->addEdge(7, 4, 5, 3, 5);
625 type->addEdge(8, 5, 3, 3, 1);
626 type->addEdge(9, 2, 4, 4, 5);
627 }
628
629 // AntiWedgeRight6
630 {
631 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
632 m_types[IT_AntiWedgeRight6] = type;
633
634 type->setInfos(this, IT_AntiWedgeRight6, "AntiWedgeRight6", Dimension::Dim3, 6, 10, 6);
635
636 type->addFaceTriangle(0, 0, 2, 1);
637 type->addFaceQuad(1, 0, 3, 5, 2);
638 type->addFaceQuad(2, 0, 1, 4, 3);
639 type->addFaceTriangle(3, 3, 4, 5);
640 type->addFaceTriangle(4, 1, 2, 5);
641 type->addFaceTriangle(5, 1, 5, 4);
642
643 type->addEdge(0, 0, 1, 0, 2);
644 type->addEdge(1, 1, 2, 4, 0);
645 type->addEdge(2, 2, 0, 1, 0);
646 type->addEdge(3, 0, 3, 1, 2);
647 type->addEdge(4, 1, 4, 2, 5);
648 type->addEdge(5, 2, 5, 4, 1);
649 type->addEdge(6, 3, 4, 3, 2);
650 type->addEdge(7, 4, 5, 3, 5);
651 type->addEdge(8, 5, 3, 3, 1);
652 type->addEdge(9, 1, 5, 5, 4);
653 }
654
655 // DiTetra5
656 {
657 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
658 m_types[IT_DiTetra5] = type;
659
660 type->setInfos(this, IT_DiTetra5, "DiTetra5", Dimension::Dim3, 5, 9, 6);
661
662 type->addFaceTriangle(0, 0, 1, 3);
663 type->addFaceTriangle(1, 1, 2, 3);
664 type->addFaceTriangle(2, 2, 0, 3);
665 type->addFaceTriangle(3, 1, 0, 4);
666 type->addFaceTriangle(4, 2, 1, 4);
667 type->addFaceTriangle(5, 0, 2, 4);
668
669 type->addEdge(0, 0, 1, 0, 3);
670 type->addEdge(1, 1, 2, 1, 4);
671 type->addEdge(2, 2, 0, 2, 5);
672 type->addEdge(3, 0, 3, 2, 0);
673 type->addEdge(4, 1, 3, 0, 1);
674 type->addEdge(5, 2, 3, 1, 2);
675 type->addEdge(6, 0, 4, 3, 5);
676 type->addEdge(7, 1, 4, 4, 3);
677 type->addEdge(8, 2, 4, 5, 4);
678 }
679
680 // DualNode
681 {
682 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
683 m_types[IT_DualNode] = type;
684
685 type->setInfos(this, IT_DualNode, "DualNode", 1, 0, 0);
686 }
687 // DualEdge
688 {
689 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
690 m_types[IT_DualEdge] = type;
691
692 type->setInfos(this, IT_DualEdge, "DualEdge", 1, 0, 0);
693 }
694 // DualFace
695 {
696 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
697 m_types[IT_DualFace] = type;
698
699 type->setInfos(this, IT_DualFace, "DualFace", 1, 0, 0);
700 }
701 // DualCell
702 {
703 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
704 m_types[IT_DualCell] = type;
705
706 type->setInfos(this, IT_DualCell, "DualCell", 1, 0, 0);
707 }
708 // DualParticle
709 {
710 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
711 m_types[IT_DualParticle] = type;
712
713 type->setInfos(this, IT_DualParticle, "DualParticle", 1, 0, 0);
714 }
715 // Link
716 {
717 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
718 m_types[IT_Link] = type;
719
720 type->setInfos(this, IT_Link, "Link", 0, 0, 0);
721 }
722
723 // Enneedron14
724 {
725 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
726 m_types[IT_Enneedron14] = type;
727
728 type->setInfos(this, IT_Enneedron14, "Enneedron14", Dimension::Dim3, 14, 21, 9);
729
730 type->addFaceHeptagon(0, 0, 6, 5, 4, 3, 2, 1);
731 type->addFaceHeptagon(1, 7, 8, 9, 10, 11, 12, 13);
732 type->addFaceQuad(2, 0, 1, 8, 7);
733 type->addFaceQuad(3, 1, 2, 9, 8);
734 type->addFaceQuad(4, 2, 3, 10, 9);
735 type->addFaceQuad(5, 3, 4, 11, 10);
736 type->addFaceQuad(6, 4, 5, 12, 11);
737 type->addFaceQuad(7, 5, 6, 13, 12);
738 type->addFaceQuad(8, 6, 0, 7, 13);
739
740 type->addEdge(0, 0, 1, 2, 0);
741 type->addEdge(1, 1, 2, 3, 0);
742 type->addEdge(2, 2, 3, 4, 0);
743 type->addEdge(3, 3, 4, 5, 0);
744 type->addEdge(4, 4, 5, 6, 0);
745 type->addEdge(5, 5, 6, 7, 0);
746 type->addEdge(6, 6, 0, 8, 0);
747 type->addEdge(7, 7, 8, 1, 2);
748 type->addEdge(8, 8, 9, 1, 3);
749 type->addEdge(9, 9, 10, 1, 4);
750 type->addEdge(10, 10, 11, 1, 5);
751 type->addEdge(11, 11, 12, 1, 6);
752 type->addEdge(12, 12, 13, 1, 7);
753 type->addEdge(13, 13, 7, 1, 8);
754 type->addEdge(14, 0, 7, 8, 2);
755 type->addEdge(15, 1, 8, 1, 2);
756 type->addEdge(16, 2, 9, 2, 3);
757 type->addEdge(17, 3, 10, 3, 4);
758 type->addEdge(18, 4, 11, 4, 5);
759 type->addEdge(19, 5, 12, 5, 6);
760 type->addEdge(20, 6, 13, 6, 7);
761 }
762 // Decaedron16
763 {
764 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
765 m_types[IT_Decaedron16] = type;
766
767 type->setInfos(this, IT_Decaedron16, "Decaedron16", Dimension::Dim3, 16, 24, 10);
768
769 type->addFaceOctogon(0, 0, 7, 6, 5, 4, 3, 2, 1);
770 type->addFaceOctogon(1, 8, 9, 10, 11, 12, 13, 14, 15);
771 type->addFaceQuad(2, 0, 1, 9, 8);
772 type->addFaceQuad(3, 1, 2, 10, 9);
773 type->addFaceQuad(4, 2, 3, 11, 10);
774 type->addFaceQuad(5, 3, 4, 12, 11);
775 type->addFaceQuad(6, 4, 5, 13, 12);
776 type->addFaceQuad(7, 5, 6, 14, 13);
777 type->addFaceQuad(8, 6, 7, 15, 14);
778 type->addFaceQuad(9, 7, 0, 8, 15);
779
780 type->addEdge(0, 0, 1, 2, 0);
781 type->addEdge(1, 1, 2, 3, 0);
782 type->addEdge(2, 2, 3, 4, 0);
783 type->addEdge(3, 3, 4, 5, 0);
784 type->addEdge(4, 4, 5, 6, 0);
785 type->addEdge(5, 5, 6, 7, 0);
786 type->addEdge(6, 6, 7, 8, 0);
787 type->addEdge(7, 7, 0, 9, 0);
788 type->addEdge(8, 8, 9, 1, 2);
789 type->addEdge(9, 9, 10, 1, 3);
790 type->addEdge(10, 10, 11, 1, 4);
791 type->addEdge(11, 11, 12, 1, 5);
792 type->addEdge(12, 12, 13, 1, 6);
793 type->addEdge(13, 13, 14, 1, 7);
794 type->addEdge(14, 14, 15, 1, 8);
795 type->addEdge(15, 15, 8, 1, 9);
796 type->addEdge(16, 0, 8, 9, 2);
797 type->addEdge(17, 1, 9, 2, 3);
798 type->addEdge(18, 2, 10, 3, 4);
799 type->addEdge(19, 3, 11, 4, 5);
800 type->addEdge(20, 4, 12, 5, 6);
801 type->addEdge(21, 5, 13, 6, 7);
802 type->addEdge(22, 6, 14, 7, 8);
803 type->addEdge(23, 7, 15, 8, 9);
804 }
805
806 // Heptagon7
807 {
808 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
809 m_types[IT_Heptagon7] = type;
810
811 type->setInfos(this, IT_Heptagon7, "Heptagon7", Dimension::Dim2, 7, 7, 7);
812
813 type->addEdgeAndFaceLine(0, { 0, 1 }, { 6, 1 });
814 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
815 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
816 type->addEdgeAndFaceLine(3, { 3, 4 }, { 2, 4 });
817 type->addEdgeAndFaceLine(4, { 4, 5 }, { 3, 5 });
818 type->addEdgeAndFaceLine(5, { 5, 6 }, { 4, 6 });
819 type->addEdgeAndFaceLine(6, { 6, 0 }, { 5, 0 });
820 }
821
822 // Octogon8
823 {
824 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
825 m_types[IT_Octogon8] = type;
826
827 type->setInfos(this, IT_Octogon8, "Octogon8", Dimension::Dim2, 8, 8, 8);
828
829 type->addEdgeAndFaceLine(0, { 0, 1 }, { 7, 1 });
830 type->addEdgeAndFaceLine(1, { 1, 2 }, { 0, 2 });
831 type->addEdgeAndFaceLine(2, { 2, 3 }, { 1, 3 });
832 type->addEdgeAndFaceLine(3, { 3, 4 }, { 2, 4 });
833 type->addEdgeAndFaceLine(4, { 4, 5 }, { 3, 5 });
834 type->addEdgeAndFaceLine(5, { 5, 6 }, { 4, 6 });
835 type->addEdgeAndFaceLine(6, { 6, 7 }, { 5, 7 });
836 type->addEdgeAndFaceLine(7, { 7, 0 }, { 6, 0 });
837 }
838
839 // Cell3D_Line2
840 {
841 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
842 m_types[IT_Cell3D_Line2] = type;
843
844 type->setInfos(this, IT_Cell3D_Line2, "Cell3D_Line2", Dimension::Dim1, 2, 0, 0);
845 }
846
847 // Cell3D_Triangle3
848 {
849 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
850 m_types[IT_Cell3D_Triangle3] = type;
851 Int32 nb_face = 3;
852 Int32 nb_edge = 0;
853 if (is_non_manifold)
854 std::swap(nb_face, nb_edge);
855
856 type->setInfos(this, IT_Cell3D_Triangle3, "Cell3D_Triangle3", Dimension::Dim2, 3, nb_edge, nb_face);
857
858 if (is_non_manifold) {
859 type->addEdge2D(0, 0, 1);
860 type->addEdge2D(1, 1, 2);
861 type->addEdge2D(2, 2, 0);
862 }
863 else {
864 type->addFaceLine(0, 0, 1);
865 type->addFaceLine(1, 1, 2);
866 type->addFaceLine(2, 2, 0);
867 }
868 }
869
870 // Cell3D_Quad4
871 {
872 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
873 m_types[IT_Cell3D_Quad4] = type;
874 Int32 nb_face = 4;
875 Int32 nb_edge = 0;
876 if (is_non_manifold)
877 std::swap(nb_face, nb_edge);
878
879 type->setInfos(this, IT_Cell3D_Quad4, "Cell3D_Quad4", Dimension::Dim2, 4, nb_edge, nb_face);
880 if (is_non_manifold) {
881 type->addEdge2D(0, 0, 1);
882 type->addEdge2D(1, 1, 2);
883 type->addEdge2D(2, 2, 3);
884 type->addEdge2D(3, 3, 0);
885 }
886 else {
887 type->addFaceLine(0, 0, 1);
888 type->addFaceLine(1, 1, 2);
889 type->addFaceLine(2, 2, 3);
890 type->addFaceLine(3, 3, 0);
891 }
892 }
893
894 { // Polygon & Polyhedron: generic item types
895 String arcane_item_type_file = platform::getEnvironmentVariable("ARCANE_ITEM_TYPE_FILE");
896 if (!arcane_item_type_file.null()) {
897 // verify the existence of item type file. if doesn't exist return an exception
898 _readTypes(parallel_mng, arcane_item_type_file);
899 }
900 }
901
902 // Calcul les relations face->arêtes
903 // Cette opération doit être appelé en fin phase build
904 for (Integer i = 0; i < m_types.size(); ++i) {
905 ItemTypeInfoBuilder* type = static_cast<ItemTypeInfoBuilder*>(m_types[i]);
906 if (!type)
907 ARCANE_FATAL("ItemType '{0}' is not defined", type);
908 type->computeFaceEdgeInfos();
909 }
910}
911
912/*---------------------------------------------------------------------------*/
913/*---------------------------------------------------------------------------*/
914
916printTypes(std::ostream& ostr)
917{
918 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
919 Integer nb_type = m_types.size();
920 ostr << "** Number of types " << nb_type << '\n';
921 for (Integer i = 0; i < nb_type; ++i) {
922 ItemTypeInfo* type = m_types[i];
923 ostr << " - Type " << type->typeId()
924 << " Name: " << type->typeName()
925 << " Nodes: " << type->nbLocalNode()
926 << " Faces " << type->nbLocalFace() << '\n';
927 for (Integer z = 0, sz = type->nbLocalFace(); z < sz; ++z) {
929 ostr << " - - Face " << z << ":";
930 for (Integer zk = 0, szk = lf.nbNode(); zk < szk; ++zk) {
931 ostr << " " << lf.node(zk);
932 }
933 ostr << "\n";
934 }
935 ostr << "\n";
936 }
937}
938
939/*---------------------------------------------------------------------------*/
940/*---------------------------------------------------------------------------*/
966_readTypes(IParallelSuperMng* pm, const String& filename)
967{
968 m_trace->info() << "Reading additional item types from file '" << filename << "'";
969
970 UniqueArray<Byte> bytes;
971 Integer size = 0;
972
973 // Lecture parallèle
974 if (pm->commRank() == 0) {
975 long unsigned int file_length = platform::getFileLength(filename);
976 if (file_length == 0)
977 throw IOException(A_FUNCINFO, "ARCANE_ITEM_TYPE_FILE is an empty file");
978 std::ifstream ifile;
979 ifile.open(filename.localstr(), std::ios::binary);
980 if (ifile.fail())
981 throw IOException(A_FUNCINFO, "Cannot open ARCANE_ITEM_TYPE_FILE item type file");
982 bytes.resize(arcaneCheckArraySize(file_length + 1));
983 ifile.read((char*)bytes.data(), file_length);
984 bytes[(Integer)file_length] = '\0';
985 if (ifile.bad())
986 throw IOException(A_FUNCINFO, "Cannot read ARCANE_ITEM_TYPE_FILE item type file");
987 size = bytes.size();
988 }
989 {
990 IntegerArrayView bs(1, &size);
991 pm->broadcast(bs, 0);
992 }
993 bytes.resize(size);
994 if (size != 0) {
995 pm->broadcast(bytes, 0);
996 }
997 else { // CC: add ending '\0'
998 bytes.resize(1);
999 bytes[0] = '\0';
1000 }
1001
1002 // Already built polygons (size => identifier)
1003 typedef std::map<Integer, Integer> PolygonMapper;
1004 PolygonMapper built_polygons;
1005 built_polygons[3] = IT_Triangle3;
1006 built_polygons[4] = IT_Quad4;
1007 built_polygons[5] = IT_Pentagon5;
1008 built_polygons[6] = IT_Hexagon6;
1009 typedef std::set<Integer> KnownTypes;
1010 KnownTypes known_types;
1011 for (Integer i_type = 0; i_type < ItemTypeMng::nbBuiltInItemType(); ++i_type)
1012 known_types.insert(i_type);
1013
1015 throw FatalErrorException(A_FUNCINFO, "Invalid initialization of built-in item types");
1016
1017 // Analyse du fichier de types
1018 std::istringstream ifile((char*)bytes.unguardedBasePointer(), std::istringstream::in);
1019 Integer nb_type = 0;
1020 ifile >> nb_type;
1021
1022 m_types.resize(ItemTypeMng::nbBuiltInItemType() + nb_type);
1023 Int16 typeId = -1, nbN = 0, nbE = 0, nbF = 0;
1024 for (Integer i = 0; i < nb_type; ++i) {
1025 ItemTypeInfoBuilder* type = m_types_buffer->allocOne();
1026 ifile >> typeId >> nbF >> nbE;
1027 if (typeId >= nb_type || typeId < 0)
1028 throw IOException(A_FUNCINFO, String::format("Polyhedron reader cannot allow typeId {0}", typeId));
1029 typeId += ItemTypeMng::nbBuiltInItemType(); // translation d'indexation
1030 if (known_types.find(typeId) != known_types.end())
1031 throw FatalErrorException(A_FUNCINFO, String::format("Already existing typeId {0}", typeId));
1032 known_types.insert(typeId);
1033 if (nbE == nbF) // 2d case nbN == nbE == nbF
1034 {
1035 nbN = nbE;
1036 }
1037 else
1038 nbN = nbE - nbF + 2; // Calcul du nb de noeuds nbN a partir de nbE et nbF (formule d'Euler)
1039
1040 type->setInfos(this, typeId, String::format("Polyhedron{0}_{1}-{2}-{3}", typeId, nbN, nbE, nbF), nbN, nbE, nbF);
1041 m_trace->debug(Trace::High) << "Adding " << type->typeName() << " type #"
1042 << typeId - ItemTypeMng::nbBuiltInItemType() << " with " << nbN << " nodes, "
1043 << nbE << " edges, " << nbF << " faces.";
1044 m_types[typeId] = type;
1045 for (Integer iface = 0; iface < nbF; ++iface) {
1046 ifile >> nbN;
1047 UniqueArray<Integer> nodeFace(nbN);
1048 for (Integer inodeFace = 0; inodeFace < nbN; ++inodeFace) {
1049 ifile >> nodeFace[inodeFace];
1050 }
1051 PolygonMapper::const_iterator finder = built_polygons.find(nbN);
1052 Int16 face_type = IT_NullType;
1053 if (finder != built_polygons.end()) {
1054 face_type = finder->second;
1055 m_trace->debug(Trace::High) << "\tAdding already existing face type " << face_type
1056 << " for face " << iface << " with " << nbN << " nodes";
1057 }
1058 else {
1059 ItemTypeInfoBuilder* type2 = m_types_buffer->allocOne();
1060
1061 face_type = m_types.size();
1062 m_types.add(type2);
1063 built_polygons[nbN] = face_type;
1064
1065 type2->setInfos(this, face_type, String::format("Polygon{0}", nbN), nbN, nbN, nbN);
1066 for (Integer j = 0; j < nbN; ++j)
1067 type2->addFaceLine(j, j, (j + 1) % nbN);
1068
1069 for (Integer j = 0; j < nbN; ++j)
1070 type2->addEdge(j, j, (j + 1) % nbN, (j - 1 + nbN) % nbN, (j + 1) % nbN);
1071 m_trace->debug(Trace::High) << "\tAdding new face type " << face_type
1072 << " for face " << iface << " with " << nbN << " nodes";
1073 }
1074 type->addFaceGeneric(iface, face_type, nodeFace);
1075 }
1076 Integer node0, node1, leftFace, rightFace;
1077 for (Integer iedge = 0; iedge < nbE; ++iedge) {
1078 ifile >> node0 >> node1 >> leftFace >> rightFace;
1079 type->addEdge(iedge, node0, node1, leftFace, rightFace);
1080 }
1081 }
1082
1083 m_trace->debug(Trace::High) << "Total number of types : " << m_types.size();
1084}
1085
1086/*---------------------------------------------------------------------------*/
1087/*---------------------------------------------------------------------------*/
1088
1091{
1092 return _singleton()->types().size();
1093}
1094
1100/*---------------------------------------------------------------------------*/
1101/*---------------------------------------------------------------------------*/
1102
1106{
1107 switch (type) {
1108 case IT_Line2:
1109 return 2;
1110 case IT_Triangle3:
1111 return 4;
1112 case IT_Quad4:
1113 return 4;
1114 case IT_Pentagon5:
1115 return 4;
1116 case IT_Hexagon6:
1117 return 4;
1118 case IT_Tetraedron4:
1119 return 8;
1120 case IT_Pyramid5:
1121 return 0;
1122 case IT_Pentaedron6:
1123 return 8;
1124 case IT_Hexaedron8:
1125 return 8;
1126 case IT_Heptaedron10:
1127 case IT_Octaedron12:
1128 case IT_HemiHexa7:
1129 case IT_HemiHexa6:
1130 case IT_HemiHexa5:
1131 case IT_AntiWedgeLeft6:
1132 case IT_AntiWedgeRight6:
1133 case IT_DiTetra5:
1134 return 0;
1135 default:
1136 ARCANE_FATAL("Not supported Item Type '{0}'", type);
1137 }
1138}
1139
1140/*---------------------------------------------------------------------------*/
1141/*---------------------------------------------------------------------------*/
1142
1144
1152
1155{
1156 //GG: Ca plante avec Windows. Regarder pourquoi.
1157#ifndef ARCANE_OS_WIN32
1158 delete singleton_instance;
1159#endif
1160 singleton_instance = nullptr;
1161}
1162
1163/*---------------------------------------------------------------------------*/
1164/*---------------------------------------------------------------------------*/
1165
1167types() const
1168{
1169 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1170 return m_types;
1171}
1172
1173/*---------------------------------------------------------------------------*/
1174/*---------------------------------------------------------------------------*/
1175
1176ItemTypeInfo* ItemTypeMng::
1177typeFromId(Integer id) const
1178{
1179 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1180 return m_types[id];
1181}
1182
1183/*---------------------------------------------------------------------------*/
1184/*---------------------------------------------------------------------------*/
1185
1186ItemTypeInfo* ItemTypeMng::
1187typeFromId(ItemTypeId id) const
1188{
1189 ARCANE_ASSERT((m_initialized), ("Cannot use not built ItemTypeMng"));
1190 return m_types[id.typeId()];
1191}
1192
1193/*---------------------------------------------------------------------------*/
1194/*---------------------------------------------------------------------------*/
1195
1197typeName(Integer id) const
1198{
1199 return typeFromId(id)->typeName();
1200}
1201
1202/*---------------------------------------------------------------------------*/
1203/*---------------------------------------------------------------------------*/
1204
1206typeName(ItemTypeId id) const
1207{
1208 return typeFromId(id)->typeName();
1209}
1210
1211/*---------------------------------------------------------------------------*/
1212/*---------------------------------------------------------------------------*/
1213// Recopie de la fonction obsolète Item::typeName().
1214// TODO: voir pourquoi il y a un test sur nBasicItemType().
1215String ItemTypeMng::
1216_legacyTypeName(Integer t)
1217{
1218 if (t >= 0 && t < nbBasicItemType())
1219 return _singleton()->typeFromId(t)->typeName();
1220 return "InvalidType";
1221}
1222
1223/*---------------------------------------------------------------------------*/
1224/*---------------------------------------------------------------------------*/
1225
1227{
1228 auto has_general_cells = false;
1230 has_general_cells = true;
1231 }
1232 return has_general_cells;
1233}
1234
1235/*---------------------------------------------------------------------------*/
1236/*---------------------------------------------------------------------------*/
1237
1239{
1240 ARCANE_ASSERT(mesh, ("Trying to indicate a null mesh contains general cells."));
1242}
1243
1244/*---------------------------------------------------------------------------*/
1245/*---------------------------------------------------------------------------*/
1246
1247} // End namespace Arcane
1248
1249/*---------------------------------------------------------------------------*/
1250/*---------------------------------------------------------------------------*/
#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.
Exception lorsqu'une erreur fatale est survenue.
Exception lorsqu'une erreur d'entrée/sortie est détectée.
Definition IOException.h:32
Classe abstraite du superviseur de parallélisme.
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 Int32 commSize() const =0
Retourne le nombre total de process utilisés.
Interface du gestionnaire de traces.
Type d'une entité (Item).
Definition ItemTypeId.h:32
void setOrder(Int16 order, ItemTypeId linear_type)
Positionne l'ordre du type.
void addFaceHexagon(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4, Integer n5)
Ajoute un hexagone à la liste des faces.
void addEdge(Integer edge_index, Integer n0, Integer n1, Integer f_left, Integer f_right)
Ajoute une arête à la liste des arêtes.
void addFacePentagon(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4)
Ajoute un pentagone à la liste des faces.
void addFaceHeptagon(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4, Integer n5, Integer n6)
Ajoute un heptagone à la liste des faces.
void addFaceQuad8(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4, Integer n5, Integer n6, Integer n7)
Ajoute un quadrilatère quadratique à la liste des faces.
void addFaceLine3(Integer face_index, Integer n0, Integer n1, Integer n2)
Ajoute une ligne quadratique à la liste des faces (pour les elements 2D)
void addFaceOctogon(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4, Integer n5, Integer n6, Integer n7)
Ajoute un heptagone à la liste des faces.
void addFaceGeneric(Integer face_index, Integer type_id, ConstArrayView< Integer > n)
Ajoute une face générique à la liste des faces.
void addEdge2D(Integer edge_index, Integer n0, Integer n1)
Ajoute une arête pour une maille 2D.
void addFaceVertex(Integer face_index, Integer n0)
Ajoute un sommet à la liste des faces (pour les elements 1D)
void addFaceTriangle(Integer face_index, Integer n0, Integer n1, Integer n2)
Ajoute un triangle à la liste des faces.
void computeFaceEdgeInfos()
Calcule les relations face->arêtes.
void addFaceQuad(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3)
Ajoute un quadrilatère à la liste des faces.
void addEdgeAndFaceLine(Int32 edge_face_index, std::array< Int16, 2 > begin_end_node, std::array< Int16, 2 > left_and_right_face)
Ajoute une arête et une face.
void addFaceLine(Integer face_index, Integer n0, Integer n1)
Ajoute une ligne à la liste des faces (pour les elements 2D)
void addFaceTriangle6(Integer face_index, Integer n0, Integer n1, Integer n2, Integer n3, Integer n4, Integer n5)
Ajoute un triangle quadratique à la liste des faces.
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
static void _destroySingleton()
Détruit le singleton.
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é)
void _readTypes(IParallelSuperMng *parallel_mng, const String &filename)
Lecture des types a partir d'un fichier de nom filename.
static Int32 nbHChildrenByItemType(Integer type)
AMR.
void _buildTypes(IMesh *mesh, IParallelSuperMng *parallel_mng, ITraceMng *trace)
Construit les types des entités.
ITraceMng * m_trace
Gestionnaire de traces.
std::set< IMesh * > m_mesh_with_general_cells
Ensemble des maillages contenant des mailles générales (sans type défini)
static Integer nbBasicItemType()
nombre de types disponibles
ItemTypeInfo * typeFromId(Integer id) const
Type correspondant au numéro id.
bool m_initialized
Flag d'initialisation.
void build(IParallelSuperMng *parallel_mng, ITraceMng *trace)
Constructeur effectif.
UniqueArray< ItemTypeInfo * > m_types
Liste des types.
static ItemTypeMng * singleton_instance
Instance singleton.
ConstArrayView< ItemTypeInfo * > types() const
Liste des types disponibles.
MultiBufferT< ItemTypeInfoBuilder > * m_types_buffer
Allocations des objets de type (il faut un pointeur pour éviter inclusion multiple)
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.
static ItemTypeMng * _singleton()
Instance singleton du type.
String typeName(Integer id) const
Nom du type correspondant au numéro id.
static const Integer m_nb_builtin_item_type
Nombre de types intégrés (hors types additionnels)
Tampon pour allocation multiple.
Definition MultiBuffer.h:44
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:227
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.