Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
DualUniqueIdMng.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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#ifndef ARCANE_MESH_DUALUNIQUEIDMNG_H
8#define ARCANE_MESH_DUALUNIQUEIDMNG_H
9
10/*---------------------------------------------------------------------------*/
11/*---------------------------------------------------------------------------*/
12#include <utility>
13#include "arcane/utils/String.h"
14#include "arcane/utils/TraceAccessor.h"
15
16/*---------------------------------------------------------------------------*/
17/*---------------------------------------------------------------------------*/
18
19/*
20 * Stratégie de numérotation des UniqueId des item (DualNode, Link) d'un graphe
21 *
22 * DualNode :
23 * --------
24 *
25 * L'UniqueId est crée à partir de celui de l'item
26 * Pour le moment, on suppose que l'UniqueId de l'item est codé sur 30 bits,
27 * ce qui signifie qu'on autorise 2^30 items (environ 1 milliard)
28 *
29 * DualNode avec DualItem de type Node :
30 * [ 29 bit (Node UniqueId) |
31 * 32 bit (0) |
32 * 2 bit (Code Node 0 0) |
33 * 1 bit (Signe positif 0 )]
34 * = 64 bit
35 *
36 * DualNode avec DualItem de type Face :
37 * [ 29 bit (Face UniqueId) |
38 * 32 bit (0) |
39 * 2 bit (Code Face 0 1) |
40 * 1 bit (Signe positif 0 )]
41 * = 64 bit
42 *
43 * DualNode avec DualItem de type Cell :
44 * [ 29 bit (Cell UniqueId) |
45 * 32 bit (0) |
46 * 2 bit (Code Cell 1 0) |
47 * 1 bit (Signe positif 0 )]
48 * = 64 bit
49 *
50 * DualNode avec DualItem de type Edge :
51 * [ 29 bit (Edge UniqueId) |
52 * 32 bit (0) |
53 * 2 bit (Code Edge 1 1) |
54 * 1 bit (Signe positif 0 )]
55 * = 64 bit
56 *
57 * On donne la possibilité de créer plusieurs DualNodes par item. Dans ce cas, les DualNodes sont
58 * différentier par leur rang (sur 4 bits soit 2^4=16 dualnodes par items au maximum)
59 * Dans ce cas d'utilisation on autorise seulement 2^25 items (=33 554 432 items)
60 *
61 * DualNode avec DualItem de type Node|Face|Cell|Edge :
62 * [ 25 bit (Item UniqueId) |
63 * [ 4 bit (DualItem rank) |
64 * 32 bit (0) |
65 * 2 bit (Code Edge 1 1) |
66 * 1 bit (Signe positif 0 )]
67 * = 64 bit
68 *
69 * Link :
70 * ----
71 *
72 * On concatène les UniqueIds des items que joint le lien Link
73 *
74 * Link liant Item_1 et Item_2 =
75 * [ 29 bit (Item_1 UniqueId) |
76 * 29 bit (Item_2 UniqueId) |
77 * 1 bit (0) |
78 * 2 bit (Code Item_1) |
79 * 2 bit (Code Item_2) |
80 * 1 bit (Signe positif 0 )]
81 * = 64 bit
82 *
83 * Si plusieurs dualnodes par item, on précise les rangs des dualnodes des l'items liés.
84 *
85 * Link liant DualItem_1 rang_1 et DualItem_2 rang_2 =
86 * [ 25 bit (Item_1 UniqueId) |
87 * [ 4 bit (DualItem_1 rank) |
88 * [ 25 bit (Item_2 UniqueId) |
89 * [ 4 bit (DualItem_2 rank) |
90 * 1 bit (0) |
91 * 2 bit (Code Item_1) |
92 * 2 bit (Code Item_2) |
93 * 1 bit (Signe positif 0 )]
94 * = 64 bit
95 *
96 *
97 */
98
99/*---------------------------------------------------------------------------*/
100/*---------------------------------------------------------------------------*/
101
102#include "arcane/utils/ArcaneGlobal.h"
103#include "arcane/Item.h"
104#include "arcane/utils/TraceAccessor.h"
105#include "arcane/utils/FatalErrorException.h"
106
107/*---------------------------------------------------------------------------*/
108/*---------------------------------------------------------------------------*/
109
110ARCANE_BEGIN_NAMESPACE
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115class ARCANE_MESH_EXPORT DualUniqueIdMng
116 : public TraceAccessor
117{
118private:
119
120 using TraceAccessor::info;
121
122public:
123
124 static const Int64 node_code = 0;
125 static const Int64 face_code = Int64(1) << 62;
126 static const Int64 cell_code = Int64(1) << 61;
127 static const Int64 edge_code = (Int64(1) << 61) + (Int64(1) << 62);
128 static const Int64 particle_code = (Int64(1) << 61) + (Int64(1) << 62);
129
130 bool m_use_dual_particle = true ;
131
132 DualUniqueIdMng(ITraceMng * trace_mng,bool use_dual_particle=true)
133 : TraceAccessor(trace_mng)
134 , m_use_dual_particle(use_dual_particle)
135 {}
136
137 ~DualUniqueIdMng() {}
138
139public:
140 inline eItemKind codeToItemKind(Int64 code) ;
141 inline eItemKind uidToDualItemKind(Int64 unique_id) ;
142 inline Int64 uniqueIdOf(eItemKind item_kind, Int64 item_uid);
143
144 template<typename ItemT>
145 inline static Int64 uniqueIdOf(const ItemT& item);
146
147 template<typename ItemT>
148 inline Int64 debugUniqueIdOf(const ItemT& item);
149
150 inline std::tuple<eItemKind,Int64> uniqueIdOfDualItem(const DoF& item);
151
152 template<typename ItemT>
153 inline static Int64 uniqueIdOf(const ItemT& item, const Integer rank);
154
155 template<typename ItemT_1, typename ItemT_2>
156 inline static Int64 uniqueIdOf(const ItemT_1& item_1, const ItemT_2& item_2);
157
158 inline std::pair< std::tuple<eItemKind,Int64>,std::tuple<eItemKind,Int64> > uniqueIdOfPairOfDualItems(const DoF& item);
159
160 template<typename ItemT_1, typename ItemT_2>
161 inline static Int64 uniqueIdOf(const ItemT_1& item_1, const Integer item_1_rank,
162 const ItemT_2& item_2, const Integer item_2_rank);
163
164 inline static Integer rankOf(const DoF& );
165
166 inline void info(const DoF& node, const Item& dual_item) const;
167 inline void info(const DoF& link, const DoF& dual_node0, const DoF& dual_node1, const Item& dual_item0, const Item& dual_item1) const;
168
169 inline Int64 debugDualItemUniqueId(DoF& node) const;
170
171private:
172
173 template<typename ItemT, typename Type>
174 struct traits_item_code;
175
176 template<Integer Nbit,typename Type>
177 inline static bool _onlyFirstBitUsed(const Type id);
178
179 inline bool _checkDualNode(const DoF& node, const Item& dual_item) const;
180 inline bool _checkLink (const DoF& link, const Item& dual_item0, const Item& dual_item1) const;
181
182 inline Int64 _extractFirstCode (const Int64 id) const;
183 inline Int64 _extractSecondCode(const Int64 id) const;
184 inline Int64 _extractFirstId (const Int64 id) const;
185 inline Int64 _extractSecondId(const Int64 id) const;
186
187 inline bool _codeIsValid(const Item& item, const Int64 code) const;
188 inline bool _idIsValid(const Item& item, const Int64 id ) const;
189};
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194// Code des DualNode en fonction des Item
195template<>
196struct ARCANE_MESH_EXPORT DualUniqueIdMng::traits_item_code<Node,Int64>
197{
198 static const Int64 code = 0;
199};
200
201template<>
202struct ARCANE_MESH_EXPORT DualUniqueIdMng::traits_item_code<Face,Int64>
203{
204 static const Int64 code = Int64(1) << 62;
205};
206
207template<>
208struct ARCANE_MESH_EXPORT DualUniqueIdMng::traits_item_code<Cell,Int64>
209{
210 static const Int64 code = Int64(1) << 61;
211}
212;
213template<>
214struct ARCANE_MESH_EXPORT DualUniqueIdMng::traits_item_code<Edge,Int64>
215{
216 static const Int64 code = (Int64(1) << 61) + (Int64(1) << 62);
217};
218
219template<>
220struct ARCANE_MESH_EXPORT DualUniqueIdMng::traits_item_code<Particle,Int64>
221{
223 static const Int64 code = (Int64(1) << 61) + (Int64(1) << 62);
224};
225
226/*---------------------------------------------------------------------------*/
227/*---------------------------------------------------------------------------*/
228
229// Verifie que seuls les Nbit premiers bits sont utilisés
230//
231// Exemple:
232// bool onlyFirstBitUsed<4,Integer>(Integer id) avec sizeof(Integer) = 8 bits
233// la méthode renvoie vrai si l'entier id est codé sur les 4 premiers bits,
234// (ie si les 4 derniers bits sont à 0)
235//
236// Par cela, on cree un filtre valant 1 pour les 4 derniers bits et on
237// utilise la comparaison binaire &. Si le résultat est nul, on renvoie vrai
238//
239template<Integer Nbit,typename Type>
240inline bool
241DualUniqueIdMng::
242_onlyFirstBitUsed(const Type id)
243{
244 ARCANE_ASSERT((Nbit > 0),("Error template parameter Nbit <= 0"));
245
246 [[maybe_unused]] const Integer nb_bit_max = (Integer)(8*sizeof(Type));
247
248 ARCANE_ASSERT((Nbit < nb_bit_max),("Error 8*sizeof(Type) <= Nbit"));
249
250 // filtre sur les nb_bit_max - Nbit derniers bits
251 const Type Nbit_first_bits_nulls = ~ ( (1 << Nbit) - 1 );
252
253 // Si les nb_bit_max - Nbit derniers bits sont nuls, vrai
254 return (Nbit_first_bits_nulls & id) == Type(0);
255}
256
257/*---------------------------------------------------------------------------*/
258/*---------------------------------------------------------------------------*/
259
260template<typename ItemT>
261inline Int64
262DualUniqueIdMng::
263uniqueIdOf(const ItemT& item)
264{
265 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
266 ARCANE_ASSERT((_onlyFirstBitUsed<29,Int64>(item.uniqueId())),
267 (String::format("Item kind={0} uid={1} : invalid uid (more than 29 bit)",
268 itemKindName(item.kind()),item.uniqueId()).localstr()));
269
270 const Int64 unique_id = item.uniqueId();
271
272 return unique_id | traits_item_code<ItemT,Int64>::code;
273}
274
275
276template<typename ItemT>
277inline Int64
278DualUniqueIdMng::
279debugUniqueIdOf(const ItemT& item)
280{
281 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
282 ARCANE_ASSERT((_onlyFirstBitUsed<29,Int64>(item.uniqueId())),
283 (String::format("Item kind={0} uid={1} : invalid uid (more than 29 bit)",
284 itemKindName(item.kind()),item.uniqueId()).localstr()));
285
286 const Int64 unique_id = item.uniqueId();
287
288 return unique_id | traits_item_code<ItemT,Int64>::code;
289}
290
291inline eItemKind
292DualUniqueIdMng::
293uidToDualItemKind(Int64 unique_id)
294{
295 Int64 code = _extractSecondCode(unique_id) ;
296
297 if(code==face_code)
298 return IK_Face ;
299 if(code==node_code)
300 return IK_Node ;
301 if(code==cell_code)
302 return IK_Cell ;
303 if(m_use_dual_particle && code==particle_code)
304 return IK_Particle ;
305 else if(code==edge_code)
306 return IK_Edge ;
307 return IK_Unknown ;
308}
309
310
311inline eItemKind
312DualUniqueIdMng::
313codeToItemKind(Int64 code)
314{
315 if(code==face_code)
316 return IK_Face ;
317 if(code==node_code)
318 return IK_Node ;
319 if(code==cell_code)
320 return IK_Cell ;
321 if(m_use_dual_particle && code==particle_code)
322 return IK_Particle ;
323 else if(code==edge_code)
324 return IK_Edge ;
325
326 return IK_Unknown ;
327}
328
329inline Int64
330DualUniqueIdMng::
331uniqueIdOf(eItemKind item_kind, Int64 item_uid)
332{
333 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
334 ARCANE_ASSERT((_onlyFirstBitUsed<29,Int64>(item_uid)),
335 (String::format("Item kind={0} uid={1} : invalid uid (more than 29 bit)",
336 itemKindName(item_kind),item_uid).localstr()));
337
338 switch(item_kind)
339 {
340 case IK_Node :
341 return item_uid | node_code ;
342 case IK_Face :
343 return item_uid | face_code ;
344 case IK_Cell :
345 return item_uid | cell_code ;
346 case IK_Edge :
347 return item_uid | edge_code ;
348 case IK_Particle :
349 return item_uid | particle_code ;
350 default :
351 throw FatalErrorException(A_FUNCINFO,"Item not defined in graph");
352 }
353 return -1 ;
354}
355
356inline std::tuple<eItemKind,Int64>
357DualUniqueIdMng::
358uniqueIdOfDualItem(const DoF& node)
359{
360 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
361 const Int64 node_id = node.uniqueId();
362 const Int64 dual_id = _extractFirstId(node_id);
363 eItemKind item_kind = uidToDualItemKind(node_id) ;
364
365 return std::make_tuple(item_kind,dual_id) ;
366}
367
368
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373template<typename ItemT>
374inline Int64
375DualUniqueIdMng::
376uniqueIdOf(const ItemT& item, const Integer rank)
377{
378 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
379 ARCANE_ASSERT((_onlyFirstBitUsed<25,Int64>(item.uniqueId())),
380 (String::format("Item kind={0} uid={1} : invalid uid (more than 25 bit)",
381 itemKindName(item.kind()),item.uniqueId()).localstr()));
382 ARCANE_ASSERT((_onlyFirstBitUsed<4,Int64>(Int64(rank))),
383 (String::format("rank={0} : invalid level (more than 4 bit)", rank).localstr()));
384
385 const Int64 unique_id = item.uniqueId();
386
387 return unique_id | Int64(rank) << 25 | traits_item_code<ItemT,Int64>::code;
388}
389
390/*---------------------------------------------------------------------------*/
391/*---------------------------------------------------------------------------*/
392
393template<typename ItemT_1, typename ItemT_2>
394inline Int64
395DualUniqueIdMng::
396uniqueIdOf(const ItemT_1& item_1, const ItemT_2& item_2)
397{
398 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
399 ARCANE_ASSERT((_onlyFirstBitUsed<29,Int64>(item_1.uniqueId())),
400 (String::format("Item kind={0} uid={1} : invalid uid (more than 29 bit)",
401 itemKindName(item_1.kind()),item_1.uniqueId()).localstr()));
402 ARCANE_ASSERT((_onlyFirstBitUsed<29,Int64>(item_2.uniqueId())),
403 (String::format("Item kind={0} uid={1} : invalid uid (more than 29 bit)",
404 itemKindName(item_2.kind()),item_2.uniqueId()).localstr()));
405
406 const Int64 item_1_unique_id = item_1.uniqueId();
407 const Int64 item_2_unique_id = item_2.uniqueId();
408
409 return item_1_unique_id | // id de l'item 1 sur 29 bits
410 item_2_unique_id << 29 | // id de l'item 2 sur 29 bits suivants
411 traits_item_code<ItemT_1,Int64>::code >> 2 | // code de l'item 1 sur 2 bits suivants
412 traits_item_code<ItemT_2,Int64>::code; // code de l'item 2 sur 2 derniers bits
413}
414
415
416inline std::pair<std::tuple<eItemKind,Int64>,std::tuple<eItemKind,Int64> >
417DualUniqueIdMng::
418uniqueIdOfPairOfDualItems(const DoF& link)
419{
420 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
421
422 const Int64 link_id = link.uniqueId();
423
424 const Int64 code_1 = _extractFirstCode(link_id);
425 const Int64 id_1 = _extractFirstId(link_id);
426 const eItemKind kind_1 = codeToItemKind(code_1) ;
427
428 const Int64 code_2 = _extractSecondCode(link_id);
429 const Int64 id_2 = _extractSecondId(link_id);
430 const eItemKind kind_2 = codeToItemKind(code_2) ;
431
432
433 return std::make_pair(std::make_tuple(kind_1,id_1),std::make_tuple(kind_2,id_2)) ;
434}
435
436
437/*---------------------------------------------------------------------------*/
438/*---------------------------------------------------------------------------*/
439
440template<typename ItemT_1, typename ItemT_2>
441inline Int64
442DualUniqueIdMng::
443uniqueIdOf(const ItemT_1& item_1, const Integer item_1_rank, const ItemT_2& item_2, const Integer item_2_rank)
444{
445 ARCANE_ASSERT((8*sizeof(Int64) == 64),("Int64 is not 64-bits"));
446 ARCANE_ASSERT((_onlyFirstBitUsed<25,Int64>(item_1.uniqueId())),
447 (String::format("Item kind={0} uid={1} : invalid uid (more than 25 bit)",
448 itemKindName(item_1.kind()),item_1.uniqueId()).localstr()));
449 ARCANE_ASSERT((_onlyFirstBitUsed<4,Int64>(Int64(item_1_rank))),
450 (String::format("rank={0} : invalid level (more than 4 bit)", item_1_rank).localstr()));
451 ARCANE_ASSERT((_onlyFirstBitUsed<25,Int64>(item_2.uniqueId())),
452 (String::format("Item kind={0} uid={1} : invalid uid (more than 25 bit)",
453 itemKindName(item_2.kind()),item_2.uniqueId()).localstr()));
454 ARCANE_ASSERT((_onlyFirstBitUsed<4,Int64>(Int64(item_2_rank))),
455 (String::format("rank={0} : invalid level (more than 4 bit)", item_2_rank).localstr()));
456
457 const Int64 item_1_unique_id = item_1.uniqueId();
458 const Int64 item_2_unique_id = item_2.uniqueId();
459
460 return item_1_unique_id | // id de l'item 1 sur 25 bits
461 Int64(item_1_rank) << 25 | // rang de l'item 1 sur 4 bits
462 item_2_unique_id << 29 | // id de l'item 2 sur 25 bits suivants
463 Int64(item_2_rank) << 54 | // rang de l'item 2 sur 4 bits suivants
464 traits_item_code<ItemT_1,Int64>::code >> 2 | // code de l'item 1 sur 2 bits suivants
465 traits_item_code<ItemT_2,Int64>::code; // code de l'item 2 sur 2 derniers bits
466}
467
468/*---------------------------------------------------------------------------*/
469/*---------------------------------------------------------------------------*/
470inline Integer
471DualUniqueIdMng::
472rankOf(const DoF& node)
473{
474 const Int64 id = node.uniqueId();
475 return Integer(( ~( (Int64(1) << 25) - 1) & id ) >> 25);
476}
477
478/*---------------------------------------------------------------------------*/
479/*---------------------------------------------------------------------------*/
480inline bool
481DualUniqueIdMng::
482_codeIsValid(const Item& item, const Int64 code) const
483{
484 const eItemKind item_kind = item.kind();
485 switch(item_kind)
486 {
487 case IK_Face :
488 if(code != traits_item_code<Face,Int64>::code) {
489 return false;
490 }
491 break;
492 case IK_Node :
493 if(code != traits_item_code<Node,Int64>::code) {
494 return false;
495 }
496 break;
497 case IK_Cell :
498 if(code != traits_item_code<Cell,Int64>::code) {
499 return false;
500 }
501 break;
502 case IK_Edge :
503 if(code != traits_item_code<Edge,Int64>::code) {
504 return false;
505 }
506 break;
507 case IK_Particle :
508 if(code != traits_item_code<Particle,Int64>::code) {
509 return false;
510 }
511 break;
512 default:
513 throw FatalErrorException(A_FUNCINFO,"Item not defined in graph");
514 }
515 return true;
516}
517
518/*---------------------------------------------------------------------------*/
519/*---------------------------------------------------------------------------*/
520
521inline bool
522DualUniqueIdMng::
523_idIsValid(const Item& item, const Int64 id) const
524{
525 return (id != item.uniqueId()) ? false : true;
526}
527
528/*---------------------------------------------------------------------------*/
529/*---------------------------------------------------------------------------*/
530
531inline Int64
532DualUniqueIdMng::
533_extractSecondCode(const Int64 id) const
534{
535 return ~ ( (Int64(1) << 61) - 1 ) & id;
536}
537
538/*---------------------------------------------------------------------------*/
539/*---------------------------------------------------------------------------*/
540
541inline Int64
542DualUniqueIdMng::
543_extractFirstId(const Int64 id) const
544{
545 return ( (Int64(1) << 29) - 1 ) & id;
546}
547
548/*---------------------------------------------------------------------------*/
549/*---------------------------------------------------------------------------*/
550
551inline Int64
552DualUniqueIdMng::
553_extractFirstCode(const Int64 id) const
554{
555 return ( ~( ((Int64(1) << 59) - 1) | ~((Int64(1) << 61) - 1 ) ) & id ) << 2;
556}
557
558/*---------------------------------------------------------------------------*/
559/*---------------------------------------------------------------------------*/
560
561inline Int64
562DualUniqueIdMng::
563_extractSecondId(const Int64 id) const
564{
565 return ( ~( ((Int64(1) << 29) - 1) | ~((Int64(1) << 59) - 1 ) ) & id ) >> 29;
566}
567
568/*---------------------------------------------------------------------------*/
569/*---------------------------------------------------------------------------*/
570
571inline bool
572DualUniqueIdMng::
573_checkDualNode(const DoF& node, const Item& dual_item) const
574{
575 const Int64 node_id = node.uniqueId();
576
577 const Int64 code = _extractSecondCode(node_id);
578 const Int64 id = _extractFirstId(node_id);
579
580
581 return _codeIsValid(dual_item,code) && _idIsValid(dual_item,id);
582}
583
584/*---------------------------------------------------------------------------*/
585/*---------------------------------------------------------------------------*/
586
587inline bool
588DualUniqueIdMng::
589_checkLink(const DoF& link, const Item& item_1, const Item& item_2) const
590{
591
592 const Int64 link_id = link.uniqueId();
593
594 const Int64 code_1 = _extractFirstCode(link_id);
595 const Int64 id_1 = _extractFirstId(link_id);
596
597 const Int64 code_2 = _extractSecondCode(link_id);
598 const Int64 id_2 = _extractSecondId(link_id);
599
600
601 return _codeIsValid(item_1,code_1) && _idIsValid(item_1,id_1)
602 && _codeIsValid(item_2,code_2) && _idIsValid(item_2,id_2);
603}
604
605/*---------------------------------------------------------------------------*/
606/*---------------------------------------------------------------------------*/
607
608inline void
609DualUniqueIdMng::
610info(const DoF& node, const Item& dual_item) const
611{
612 ARCANE_ASSERT((_checkDualNode(node,dual_item) == true),("Error from dual node consistence. Do you use DualUniqueIdMng to generate unique id of graph item ?"));
613
614
615 info() << " -- Dual Node with unique id " << node.uniqueId()
616 << " of item of kind " << dual_item.kind()
617 << " and unique id " << dual_item.uniqueId();
618}
619
620/*---------------------------------------------------------------------------*/
621/*---------------------------------------------------------------------------*/
622
623inline void
624DualUniqueIdMng::
625info(const DoF& link, const DoF& dual_node0, const DoF& dual_node1,const Item& dual_item0, const Item& dual_item1) const
626{
627 ARCANE_ASSERT((_checkLink(link,dual_item0,dual_item1) == true),("Error from link consistence. Do you use DualUniqueIdMng to generate unique id of graph item ?"));
628
629 info() << "- Link with unique id " << link.uniqueId() << " of :";
630
631 info(dual_node0,dual_item0);
632
633 info() << " and :";
634
635 info(dual_node1,dual_item1);
636}
637
638/*---------------------------------------------------------------------------*/
639/*---------------------------------------------------------------------------*/
640
641ARCANE_END_NAMESPACE
642
643/*---------------------------------------------------------------------------*/
644/*---------------------------------------------------------------------------*/
645
646#endif /* MESH_UTILS_DUALUNIQUEIDMNG_H */
ArcaneGlobal.h
Fichier de configuration d'Arcane.
Arcane::DoF
classe degré de liberté.
Definition Item.h:1503
Arcane::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arcane::Item
Classe de base d'un élément de maillage.
Definition Item.h:83
Arcane::TraceAccessor::TraceAccessor
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
Definition TraceAccessor.cc:27
Arcane::TraceAccessor::info
TraceMessage info() const
Flot pour un message d'information.
Definition TraceAccessor.cc:101
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:168
Arcane::IK_Particle
@ IK_Particle
Entité de maillage de genre particule.
Definition ArcaneTypes.h:174
Arcane::IK_Node
@ IK_Node
Entité de maillage de genre noeud.
Definition ArcaneTypes.h:169
Arcane::IK_Cell
@ IK_Cell
Entité de maillage de genre maille.
Definition ArcaneTypes.h:172
Arcane::IK_Unknown
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
Definition ArcaneTypes.h:175
Arcane::IK_Face
@ IK_Face
Entité de maillage de genre face.
Definition ArcaneTypes.h:171
Arcane::IK_Edge
@ IK_Edge
Entité de maillage de genre arête.
Definition ArcaneTypes.h:170
Arcane::itemKindName
const char * itemKindName(eItemKind kind)
Nom du genre d'entité.
Definition ArcaneTypes.cc:37
Type
Type
Type of JSON value.
Definition rapidjson.h:665
Arcane::DualUniqueIdMng::traits_item_code< Particle, Int64 >::code
static const Int64 code
attention incompatible avec une utilisation silmutanée de dual node sur des arêtes et des particules
Definition DualUniqueIdMng.h:223
Arcane::DualUniqueIdMng::traits_item_code
Definition DualUniqueIdMng.h:174