Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Item.h
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/* Item.h (C) 2000-2025 */
9/* */
10/* Informations sur les éléments du maillage. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ITEM_H
13#define ARCANE_CORE_ITEM_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
18#include "arcane/core/ItemInternal.h"
19#include "arcane/core/ItemLocalId.h"
20
21#include <atomic>
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26namespace Arcane
27{
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32// Macro pour vérifier en mode Check que les conversions entre les
33// les genres d'entités sont correctes.
34#ifdef ARCANE_CHECK
35#define ARCANE_CHECK_KIND(type) _checkKind(type())
36#else
37#define ARCANE_CHECK_KIND(type)
38#endif
39
40#ifdef ARCANE_CHECK
41#define ARCANE_WANT_ITEM_STAT
42#endif
43
44#ifdef ARCANE_WANT_ITEM_STAT
45#define ARCANE_ITEM_ADD_STAT(var) ++var
46#else
47#define ARCANE_ITEM_ADD_STAT(var)
48#endif
49
50/*---------------------------------------------------------------------------*/
51/*---------------------------------------------------------------------------*/
82class ARCANE_CORE_EXPORT Item
83{
84 // Pour accéder aux constructeurs privés
85 friend class ItemEnumeratorBaseT<Item>;
87 friend class ItemVector;
88 friend class ItemVectorView;
89 friend class ItemVectorViewConstIterator;
90 friend class ItemConnectedListViewConstIterator;
91 friend class SimdItem;
92 friend class SimdItemEnumeratorBase;
93 friend class ItemInfoListView;
94 friend class ItemLocalIdToItemConverter;
95 template<typename ItemType> friend class ItemLocalIdToItemConverterT;
96 friend class ItemPairEnumerator;
97 template<int Extent> friend class ItemConnectedListView;
98 template<typename ItemType> friend class ItemEnumeratorBaseT;
99
100 // Pour accéder à _internal()
101 friend class ItemCompatibility;
102
103 public:
104
105 typedef ItemInternal* ItemInternalPtr;
106
109
110 using ItemBase = impl::ItemBase;
111
112 public:
113
117 */
118 class Index
119 {
120 // TODO Rendre obsolète lorsqu'on aura supprimer
121 // les classes dérivées qui sont obsolètes.
122 // On ne peut pas le faire avant car cela génère trop
123 // d'avertissements de compilation.
124 public:
125 Index() : m_local_id(NULL_ITEM_LOCAL_ID){}
126 explicit Index(Int32 id) : m_local_id(id){}
127 Index(Item item) : m_local_id(item.localId()){}
128 operator ItemLocalId() const { return ItemLocalId{m_local_id}; }
129 public:
130 Int32 localId() const { return m_local_id; }
131 private:
132 Int32 m_local_id;
133 };
134
135 public:
136
144 enum
145 {
146 Unknown ARCANE_DEPRECATED_REASON("Use 'IT_NullType' instead") = IT_NullType,
147 Vertex ARCANE_DEPRECATED_REASON("Use 'IT_Vertex' instead") = IT_Vertex,
148 Bar2 ARCANE_DEPRECATED_REASON("Use 'IT_Line2' instead") = IT_Line2,
149 Tri3 ARCANE_DEPRECATED_REASON("Use 'IT_Triangle3' instead") = IT_Triangle3,
150 Quad4 ARCANE_DEPRECATED_REASON("Use 'IT_Quad4' instead") = IT_Quad4,
151 Pentagon5 ARCANE_DEPRECATED_REASON("Use 'IT_Pentagon5' instead") = IT_Pentagon5,
152 Hexagon6 ARCANE_DEPRECATED_REASON("Use 'IT_Hexagon6' instead") = IT_Hexagon6,
153 Tetra ARCANE_DEPRECATED_REASON("Use 'IT_Tetraedron4' instead") = IT_Tetraedron4,
154 Pyramid ARCANE_DEPRECATED_REASON("Use 'IT_Pyramid5' instead") = IT_Pyramid5,
155 Penta ARCANE_DEPRECATED_REASON("Use 'IT_Pentaedron6' instead") = IT_Pentaedron6,
156 Hexa ARCANE_DEPRECATED_REASON("Use 'IT_Hexaedron8' instead") = IT_Hexaedron8,
157 Wedge7 ARCANE_DEPRECATED_REASON("Use 'IT_Heptaedron10' instead") = IT_Heptaedron10,
158 Wedge8 ARCANE_DEPRECATED_REASON("Use 'IT_Octaedron12' instead") = IT_Octaedron12
159 // Réduit au minimum pour compatibilité.
160 };
161
163 static const Int32 NULL_ELEMENT = NULL_ITEM_ID;
164
166 ARCCORE_DEPRECATED_2021("Use ItemTypeMng::typeName() instead")
167 static String typeName(Int32 type);
168
169 protected:
170
172 constexpr ARCCORE_HOST_DEVICE Item(Int32 local_id,ItemSharedInfo* shared_info)
173 : m_shared_info(shared_info), m_local_id(local_id) {}
174
175 public:
176
177 //! Création d'une entité de maillage nulle
178 Item() = default;
181 //ARCANE_DEPRECATED_REASON("Remove this overload")
182 Item(ItemInternal* ainternal)
183 {
184 ARCANE_CHECK_PTR(ainternal);
185 m_shared_info = ainternal->m_shared_info;
186 m_local_id = ainternal->m_local_id;
187 ARCANE_ITEM_ADD_STAT(m_nb_created_from_internal);
188 }
189
190 // NOTE: Pour le constructeur suivant; il est indispensable d'utiliser
191 // const& pour éviter une ambiguité avec le constructeur par recopie
193 constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase)
195 , m_local_id(abase.m_local_id)
196 {
197 }
198
200 Item(const ItemInternalPtr* internals,Int32 local_id)
201 : Item(local_id,internals[local_id]->m_shared_info)
202 {
203 ARCANE_ITEM_ADD_STAT(m_nb_created_from_internalptr);
204 }
205
208 {
209 _set(ainternal);
210 return (*this);
211 }
212
213 public:
214
216 constexpr bool null() const { return m_local_id==NULL_ITEM_ID; }
217
219 constexpr Int32 localId() const { return m_local_id; }
220
222 constexpr ItemLocalId itemLocalId() const { return ItemLocalId{ m_local_id }; }
223
226 {
227#ifdef ARCANE_CHECK
228 if (m_local_id!=NULL_ITEM_LOCAL_ID)
229 arcaneCheckAt((Integer)m_local_id,m_shared_info->m_unique_ids.size());
230#endif
231 // Ne pas utiliser l'accesseur normal car ce tableau peut etre utilise pour la maille
232 // nulle et dans ce cas m_local_id vaut NULL_ITEM_LOCAL_ID (qui est negatif)
233 // ce qui provoque une exception pour debordement de tableau.
234 return ItemUniqueId(m_shared_info->m_unique_ids.data()[m_local_id]);
235 }
236
238 Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }
239
241 Int16 type() const { return m_shared_info->_typeId(m_local_id); }
242
244 ItemTypeId itemTypeId() const { return ItemTypeId(type()); }
245
247 IItemFamily* itemFamily() const { return m_shared_info->m_item_family; }
248
250 eItemKind kind() const { return m_shared_info->m_item_kind; }
251
253 bool isOwn() const { return (_flags() & ItemFlags::II_Own)!=0; }
254
265 bool isShared() const { return (_flags() & ItemFlags::II_Shared)!=0; }
266
268 inline ItemWithNodes toItemWithNodes() const;
270 inline Node toNode() const;
272 inline Cell toCell() const;
274 inline Edge toEdge() const;
276 inline Face toFace() const;
278 inline Particle toParticle() const;
280 inline DoF toDoF() const;
281
283 Int32 nbParent() const { return _nbParent(); }
284
286 Item parent(Int32 i) const { return m_shared_info->_parentV2(m_local_id,i); }
287
289 Item parent() const { return m_shared_info->_parentV2(m_local_id,0); }
290
291 public:
292
294 bool isItemWithNodes() const
295 {
296 eItemKind ik = kind();
297 return (ik==IK_Unknown || ik==IK_Edge || ik==IK_Face || ik==IK_Cell );
298 }
299
301 bool isNode() const
302 {
303 eItemKind ik = kind();
304 return (ik==IK_Unknown || ik==IK_Node);
305 }
306
307 bool isCell() const
308 {
309 eItemKind ik = kind();
310 return (ik==IK_Unknown || ik==IK_Cell);
311 }
312
313 bool isEdge() const
314 {
315 eItemKind ik = kind();
316 return (ik==IK_Unknown || ik==IK_Edge);
317 }
318
319 bool isFace() const
320 {
321 eItemKind ik = kind();
322 return (ik==IK_Unknown || ik==IK_Face);
323 }
324
325 bool isParticle() const
326 {
327 eItemKind ik = kind();
328 return (ik==IK_Unknown || ik==IK_Particle);
329 }
330
331 bool isDoF() const
332 {
333 eItemKind ik = kind();
334 return (ik==IK_Unknown || ik==IK_DoF);
335 }
336
337 public:
338
347 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. use itemBase() or mutableItemBase() instead")
349 {
350 if (m_local_id!=NULL_ITEM_LOCAL_ID)
351 return m_shared_info->m_items_internal[m_local_id];
352 return ItemInternal::nullItem();
353 }
354
355 public:
356
363 impl::ItemBase itemBase() const
364 {
365 return impl::ItemBase(m_local_id,m_shared_info);
366 }
367
374 impl::MutableItemBase mutableItemBase() const
375 {
376 return impl::MutableItemBase(m_local_id,m_shared_info);
377 }
378
386 const ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(type()); }
387
388 public:
389
390 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
391 Item* operator->() { return this; }
392
393 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
394 const Item* operator->() const { return this; }
395
396 private:
397
399 ItemSharedInfo* m_shared_info = ItemSharedInfo::nullItemSharedInfoPointer;
400
401 protected:
402
409 Int32 m_local_id = NULL_ITEM_LOCAL_ID;
410
411 protected:
412
413 void _checkKind(bool is_valid) const
414 {
415 if (!is_valid)
416 _badConversion();
417 }
418 void _badConversion() const;
419 void _set(ItemInternal* ainternal)
420 {
421 _setFromInternal(ainternal);
422 }
423 void _set(const Item& rhs)
424 {
425 _setFromItem(rhs);
426 }
427
428 protected:
429
431 Int32 _flags() const { return m_shared_info->_flagsV2(m_local_id); }
433 Integer _nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }
435 Integer _nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }
437 Integer _nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }
439 Integer _nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }
441 Int32 _nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }
443 Int32 _nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }
445 Integer _nbParent() const { return m_shared_info->nbParent(); }
446 NodeLocalId _nodeId(Int32 index) const { return NodeLocalId(_connectivity()->_nodeLocalIdV2(m_local_id,index)); }
447 EdgeLocalId _edgeId(Int32 index) const { return EdgeLocalId(_connectivity()->_edgeLocalIdV2(m_local_id,index)); }
448 FaceLocalId _faceId(Int32 index) const { return FaceLocalId(_connectivity()->_faceLocalIdV2(m_local_id,index)); }
449 CellLocalId _cellId(Int32 index) const { return CellLocalId(_connectivity()->_cellLocalIdV2(m_local_id,index)); }
450 Int32 _hParentId(Int32 index) const { return _connectivity()->_hParentLocalIdV2(m_local_id,index); }
451 Int32 _hChildId(Int32 index) const { return _connectivity()->_hChildLocalIdV2(m_local_id,index); }
452 impl::ItemIndexedListView<DynExtent> _nodeList() const { return _connectivity()->nodeList(m_local_id); }
453 impl::ItemIndexedListView<DynExtent> _edgeList() const { return _connectivity()->edgeList(m_local_id); }
454 impl::ItemIndexedListView<DynExtent> _faceList() const { return _connectivity()->faceList(m_local_id); }
455 impl::ItemIndexedListView<DynExtent> _cellList() const { return _connectivity()->cellList(m_local_id); }
456 NodeLocalIdView _nodeIds() const { return _connectivity()->nodeLocalIdsView(m_local_id); }
457 EdgeLocalIdView _edgeIds() const { return _connectivity()->edgeLocalIdsView(m_local_id); }
458 FaceLocalIdView _faceIds() const { return _connectivity()->faceLocalIdsView(m_local_id); }
459 CellLocalIdView _cellIds() const { return _connectivity()->cellLocalIdsView(m_local_id); }
460
461 inline Node _node(Int32 index) const;
462 inline Edge _edge(Int32 index) const;
463 inline Face _face(Int32 index) const;
464 inline Cell _cell(Int32 index) const;
465
466 ItemBase _hParentBase(Int32 index) const { return _connectivity()->hParentBase(m_local_id, index, m_shared_info); }
467 ItemBase _hChildBase(Int32 index) const { return _connectivity()->hChildBase(m_local_id, index, m_shared_info); }
468 ItemBase _toItemBase() const { return ItemBase(m_local_id,m_shared_info); }
469
471 Int32 _nbLinearNode() const { return itemBase()._nbLinearNode(); }
472
473 private:
474
475 ItemInternalConnectivityList* _connectivity() const
476 {
477 return m_shared_info->m_connectivity;
478 }
479 void _setFromInternal(ItemBase* rhs)
480 {
481 ARCANE_ITEM_ADD_STAT(m_nb_set_from_internal);
482 m_local_id = rhs->m_local_id;
483 m_shared_info = rhs->m_shared_info;
484 }
485 void _setFromItem(const Item& rhs)
486 {
487 m_local_id = rhs.m_local_id;
488 m_shared_info = rhs.m_shared_info;
489 }
490
491 public:
492
493 static void dumpStats(ITraceMng* tm);
494 static void resetStats();
495
496 private:
497
498 static std::atomic<int> m_nb_created_from_internal;
499 static std::atomic<int> m_nb_created_from_internalptr;
500 static std::atomic<int> m_nb_set_from_internal;
501
502 private:
503
504 ItemInternal* _internal() const
505 {
506 if (m_local_id!=NULL_ITEM_LOCAL_ID)
507 return m_shared_info->m_items_internal[m_local_id];
508 return ItemInternal::nullItem();
509 }
510};
511
512/*---------------------------------------------------------------------------*/
513/*---------------------------------------------------------------------------*/
520inline bool
521operator==(const Item& item1,const Item& item2)
522{
523 return item1.localId()==item2.localId();
524}
525
532inline bool
533operator!=(const Item& item1,const Item& item2)
534{
535 return item1.localId()!=item2.localId();
536}
537
544inline bool
545operator<(const Item& item1,const Item& item2)
546{
547 return item1.localId()<item2.localId();
548}
549
550/*---------------------------------------------------------------------------*/
551/*---------------------------------------------------------------------------*/
552
553} // End namespace Arcane
554
555/*---------------------------------------------------------------------------*/
556/*---------------------------------------------------------------------------*/
557
558#include "arcane/ItemVectorView.h"
559#include "arcane/ItemConnectedListView.h"
560
561/*---------------------------------------------------------------------------*/
562/*---------------------------------------------------------------------------*/
563
564namespace Arcane
565{
566
567/*---------------------------------------------------------------------------*/
568/*---------------------------------------------------------------------------*/
574class ARCANE_CORE_EXPORT Node
575: public Item
576{
577 using ThatClass = Node;
578 // Pour accéder aux constructeurs privés
579 friend class ItemEnumeratorBaseT<ThatClass>;
580 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
581 friend class ItemVectorT<ThatClass>;
582 friend class ItemVectorViewT<ThatClass>;
583 friend class ItemConnectedListViewT<ThatClass>;
584 friend class ItemVectorViewConstIteratorT<ThatClass>;
585 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
586 friend class SimdItemT<ThatClass>;
587 friend class ItemInfoListViewT<ThatClass>;
588 friend class ItemLocalIdToItemConverterT<ThatClass>;
589
590 public:
591
596 class ARCANE_DEPRECATED_REASON("Y2024: Use NodeLocalId instead") Index
597 : public Item::Index
598 {
599 public:
600 typedef Item::Index Base;
601 public:
602 explicit Index(Int32 id) : Base(id){}
603 Index(Node item) : Base(item){}
604 operator NodeLocalId() const { return NodeLocalId{localId()}; }
605 };
606
607 protected:
608
610 Node(Int32 local_id,ItemSharedInfo* shared_info)
611 : Item(local_id,shared_info) {}
612
613 public:
614
616 typedef NodeLocalId LocalIdType;
617
619 Node() = default;
620
622 Node(ItemInternal* ainternal) : Item(ainternal)
623 { ARCANE_CHECK_KIND(isNode); }
624
626 Node(const ItemBase& abase) : Item(abase)
627 { ARCANE_CHECK_KIND(isNode); }
628
630 explicit Node(const Item& aitem) : Item(aitem)
631 { ARCANE_CHECK_KIND(isNode); }
632
634 Node(const ItemInternalPtr* internals,Int32 local_id) : Item(internals,local_id)
635 { ARCANE_CHECK_KIND(isNode); }
636
639 {
640 _set(ainternal);
641 return (*this);
642 }
643
644 public:
645
647 NodeLocalId itemLocalId() const { return NodeLocalId{ m_local_id }; }
648
650 Int32 nbEdge() const { return _nbEdge(); }
651
653 Int32 nbFace() const { return _nbFace(); }
654
656 Int32 nbCell() const { return _nbCell(); }
657
659 inline Edge edge(Int32 i) const;
660
662 inline Face face(Int32 i) const;
663
665 inline Cell cell(Int32 i) const;
666
668 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
669
671 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
672
674 CellLocalId cellId(Int32 i) const { return _cellId(i); }
675
677 EdgeConnectedListViewType edges() const { return _edgeList(); }
678
680 FaceConnectedListViewType faces() const { return _faceList(); }
681
683 CellConnectedListViewType cells() const { return _cellList(); }
684
686 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
687
689 FaceLocalIdView faceIds() const { return _faceIds(); }
690
692 CellLocalIdView cellIds() const { return _cellIds(); }
693
694 // AMR
695
698 {
699 return _toItemBase()._internalActiveCells2(local_ids);
700 }
701
702 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
703 Node* operator->() { return this; }
704
705 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
706 const Node* operator->() const { return this; }
707};
708
709/*---------------------------------------------------------------------------*/
710/*---------------------------------------------------------------------------*/
711
712inline Node Item::
713_node(Int32 index) const
714{
715 return Node(_connectivity()->nodeBase(m_local_id,index));
716}
717
718/*---------------------------------------------------------------------------*/
719/*---------------------------------------------------------------------------*/
725class ARCANE_CORE_EXPORT ItemWithNodes
726: public Item
727{
728 using ThatClass = ItemWithNodes;
729 // Pour accéder aux constructeurs privés
730 friend class ItemEnumeratorBaseT<ThatClass>;
731 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
732 friend class ItemVectorT<ThatClass>;
733 friend class ItemVectorViewT<ThatClass>;
734 friend class ItemConnectedListViewT<ThatClass>;
735 friend class ItemVectorViewConstIteratorT<ThatClass>;
736 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
737 friend class SimdItemT<ThatClass>;
738 friend class ItemInfoListViewT<ThatClass>;
739 friend class ItemLocalIdToItemConverterT<ThatClass>;
740
741 protected:
742
744 ItemWithNodes(Int32 local_id,ItemSharedInfo* shared_info)
745 : Item(local_id,shared_info) {}
746
747 public:
748
750 ItemWithNodes() = default;
751
753 ItemWithNodes(ItemInternal* ainternal) : Item(ainternal)
754 { ARCANE_CHECK_KIND(isItemWithNodes); }
755
757 ItemWithNodes(const ItemBase& abase) : Item(abase)
758 { ARCANE_CHECK_KIND(isItemWithNodes); }
759
761 explicit ItemWithNodes(const Item& aitem) : Item(aitem)
762 { ARCANE_CHECK_KIND(isItemWithNodes); }
763
765 ItemWithNodes(const ItemInternalPtr* internals,Int32 local_id)
766 : Item(internals,local_id)
767 { ARCANE_CHECK_KIND(isItemWithNodes); }
768
771 {
772 _set(ainternal);
773 return (*this);
774 }
775
776 public:
777
779 Int32 nbNode() const { return _nbNode(); }
780
782 Node node(Int32 i) const { return _node(i); }
783
785 NodeConnectedListViewType nodes() const { return _nodeList(); }
786
788 NodeLocalIdView nodeIds() const { return _nodeIds(); }
789
791 NodeLocalId nodeId(Int32 index) const { return _nodeId(index); }
792
794 Int32 nbLinearNode() const { return _nbLinearNode(); }
795
796 public:
797
798 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
799 ItemWithNodes* operator->() { return this; }
800
801 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
802 const ItemWithNodes* operator->() const { return this; }
803};
804
805/*---------------------------------------------------------------------------*/
806/*---------------------------------------------------------------------------*/
815class ARCANE_CORE_EXPORT Edge
816: public ItemWithNodes
817{
818 using ThatClass = Edge;
819 // Pour accéder aux constructeurs privés
820 friend class ItemEnumeratorBaseT<ThatClass>;
821 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
822 friend class ItemVectorT<ThatClass>;
823 friend class ItemVectorViewT<ThatClass>;
824 friend class ItemConnectedListViewT<ThatClass>;
825 friend class ItemVectorViewConstIteratorT<ThatClass>;
826 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
827 friend class SimdItemT<ThatClass>;
828 friend class ItemInfoListViewT<ThatClass>;
829 friend class ItemLocalIdToItemConverterT<ThatClass>;
830
831 public:
832
837 class ARCANE_DEPRECATED_REASON("Y2024: Use EdgeLocalId instead") Index
838 : public Item::Index
839 {
840 public:
841 typedef Item::Index Base;
842 public:
843 explicit Index(Int32 id) : Base(id){}
844 Index(Edge item) : Base(item){}
845 operator EdgeLocalId() const { return EdgeLocalId{localId()}; }
846 };
847
848 private:
849
851 Edge(Int32 local_id,ItemSharedInfo* shared_info)
852 : ItemWithNodes(local_id,shared_info) {}
853
854 public:
855
857 typedef EdgeLocalId LocalIdType;
858
860 Edge() = default;
861
863 Edge(ItemInternal* ainternal) : ItemWithNodes(ainternal)
864 { ARCANE_CHECK_KIND(isEdge); }
865
867 Edge(const ItemBase& abase) : ItemWithNodes(abase)
868 { ARCANE_CHECK_KIND(isEdge); }
869
871 explicit Edge(const Item& aitem) : ItemWithNodes(aitem)
872 { ARCANE_CHECK_KIND(isEdge); }
873
875 Edge(const ItemInternalPtr* internals,Int32 local_id)
876 : ItemWithNodes(internals,local_id)
877 { ARCANE_CHECK_KIND(isEdge); }
878
881 {
882 _set(ainternal);
883 return (*this);
884 }
885
886 public:
887
889 EdgeLocalId itemLocalId() const { return EdgeLocalId{ m_local_id }; }
890
892 Int32 nbNode() const { return 2; }
893
895 Int32 nbFace() const { return _nbFace(); }
896
898 Int32 nbCell() const { return _nbCell(); }
899
901 inline Cell cell(Int32 i) const;
902
904 CellConnectedListViewType cells() const { return _cellList(); }
905
907 CellLocalId cellId(Int32 i) const { return _cellId(i); }
908
910 CellLocalIdView cellIds() const { return _cellIds(); }
911
913 inline Face face(Int32 i) const;
914
916 FaceConnectedListViewType faces() const { return _faceList(); }
917
919 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
920
922 FaceLocalIdView faceIds() const { return _faceIds(); }
923
924 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
925 Edge* operator->() { return this; }
926
927 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
928 const Edge* operator->() const { return this; }
929};
930
931/*---------------------------------------------------------------------------*/
932/*---------------------------------------------------------------------------*/
933
934inline Edge Item::
935_edge(Int32 index) const
936{
937 return Edge(_connectivity()->edgeBase(m_local_id,index));
938}
939
940/*---------------------------------------------------------------------------*/
941/*---------------------------------------------------------------------------*/
950class ARCANE_CORE_EXPORT Face
951: public ItemWithNodes
952{
953 using ThatClass = Face;
954 // Pour accéder aux constructeurs privés
955 friend class ItemEnumeratorBaseT<ThatClass>;
956 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
957 friend class ItemVectorT<ThatClass>;
958 friend class ItemVectorViewT<ThatClass>;
959 friend class ItemConnectedListViewT<ThatClass>;
960 friend class ItemVectorViewConstIteratorT<ThatClass>;
961 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
962 friend class SimdItemT<ThatClass>;
963 friend class ItemInfoListViewT<ThatClass>;
964 friend class ItemLocalIdToItemConverterT<ThatClass>;
965
966 public:
967
972 class ARCANE_DEPRECATED_REASON("Y2024: Use FaceLocalId instead") Index
973 : public Item::Index
974 {
975 public:
976 typedef Item::Index Base;
977 public:
978 explicit Index(Int32 id) : Base(id){}
979 Index(Face item) : Base(item){}
980 operator FaceLocalId() const { return FaceLocalId{localId()}; }
981 };
982
983 private:
984
986 Face(Int32 local_id,ItemSharedInfo* shared_info)
987 : ItemWithNodes(local_id,shared_info) {}
988
989 public:
990
992 typedef FaceLocalId LocalIdType;
993
995 Face() = default;
996
998 Face(ItemInternal* ainternal) : ItemWithNodes(ainternal)
999 { ARCANE_CHECK_KIND(isFace); }
1000
1002 Face(const ItemBase& abase) : ItemWithNodes(abase)
1003 { ARCANE_CHECK_KIND(isFace); }
1004
1006 explicit Face(const Item& aitem) : ItemWithNodes(aitem)
1007 { ARCANE_CHECK_KIND(isFace); }
1008
1010 Face(const ItemInternalPtr* internals,Int32 local_id)
1011 : ItemWithNodes(internals,local_id)
1012 { ARCANE_CHECK_KIND(isFace); }
1013
1016 {
1017 _set(ainternal);
1018 return (*this);
1019 }
1020
1021 public:
1022
1024 FaceLocalId itemLocalId() const { return FaceLocalId{ m_local_id }; }
1025
1027 Int32 nbCell() const { return _nbCell(); }
1028
1030 inline Cell cell(Int32 i) const;
1031
1033 CellConnectedListViewType cells() const { return _cellList(); }
1034
1036 CellLocalId cellId(Int32 i) const { return _cellId(i); }
1037
1039 CellLocalIdView cellIds() const { return _cellIds(); }
1040
1046 bool isSubDomainBoundary() const { return (_flags() & ItemFlags::II_Boundary)!=0; }
1047
1052 ARCANE_DEPRECATED_118 bool isBoundary() const { return isSubDomainBoundary(); }
1053
1056 {
1058 }
1059
1065 ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
1066 {
1068 }
1069
1071 inline Cell boundaryCell() const;
1072
1074 inline Cell backCell() const;
1075
1077 CellLocalId backCellId() const { return CellLocalId(_toItemBase().backCellId()); }
1078
1080 inline Cell frontCell() const;
1081
1083 CellLocalId frontCellId() const { return CellLocalId(_toItemBase().frontCellId()); }
1084
1090 inline Cell oppositeCell(Cell cell) const;
1091
1097 CellLocalId oppositeCellId(CellLocalId cell_id) const
1098 {
1099 ARCANE_ASSERT((backCellId()==cell_id || frontCellId()==cell_id),("cell is not connected to the face"));
1100 return (backCellId()==cell_id) ? frontCellId() : backCellId();
1101 }
1102
1111 Face masterFace() const { return _toItemBase().masterFace(); }
1112
1114 bool isMasterFace() const { return _toItemBase().isMasterFace(); }
1115
1117 bool isSlaveFace() const { return _toItemBase().isSlaveFace(); }
1118
1120 bool isTiedFace() const { return isSlaveFace() || isMasterFace(); }
1121
1129 {
1130 if (_toItemBase().isMasterFace())
1131 return _faceList();
1133 }
1134
1135 public:
1136
1138 Int32 nbEdge() const { return _nbEdge(); }
1139
1141 Edge edge(Int32 i) const { return _edge(i); }
1142
1144 EdgeConnectedListViewType edges() const { return _edgeList(); }
1145
1147 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
1148
1150 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
1151
1152 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1153 Face* operator->() { return this; }
1154
1155 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1156 const Face* operator->() const { return this; }
1157};
1158
1159/*---------------------------------------------------------------------------*/
1160/*---------------------------------------------------------------------------*/
1161
1162inline Face Item::
1163_face(Int32 index) const
1164{
1165 return Face(_connectivity()->faceBase(m_local_id,index));
1166}
1167
1168/*---------------------------------------------------------------------------*/
1169/*---------------------------------------------------------------------------*/
1197class ARCANE_CORE_EXPORT Cell
1198: public ItemWithNodes
1199{
1200 using ThatClass = Cell;
1201 // Pour accéder aux constructeurs privés
1202 friend class ItemEnumeratorBaseT<ThatClass>;
1203 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1204 friend class ItemVectorT<ThatClass>;
1205 friend class ItemVectorViewT<ThatClass>;
1206 friend class ItemConnectedListViewT<ThatClass>;
1207 friend class ItemVectorViewConstIteratorT<ThatClass>;
1208 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1209 friend class SimdItemT<ThatClass>;
1210 friend class ItemInfoListViewT<ThatClass>;
1211 friend class ItemLocalIdToItemConverterT<ThatClass>;
1212
1213 public:
1214
1219 class ARCANE_DEPRECATED_REASON("Y2024: Use CellLocalId instead") Index
1220 : public Item::Index
1221 {
1222 public:
1223 typedef Item::Index Base;
1224 public:
1225 explicit Index(Int32 id) : Base(id){}
1226 Index(Cell item) : Base(item){}
1227 operator CellLocalId() const { return CellLocalId{localId()}; }
1228 };
1229
1230 private:
1231
1233 Cell(Int32 local_id,ItemSharedInfo* shared_info)
1234 : ItemWithNodes(local_id,shared_info) {}
1235
1236 public:
1237
1239 typedef CellLocalId LocalIdType;
1240
1242 Cell() = default;
1243
1245 Cell(ItemInternal* ainternal) : ItemWithNodes(ainternal)
1246 { ARCANE_CHECK_KIND(isCell); }
1247
1249 Cell(const ItemBase& abase) : ItemWithNodes(abase)
1250 { ARCANE_CHECK_KIND(isCell); }
1251
1253 explicit Cell(const Item& aitem) : ItemWithNodes(aitem)
1254 { ARCANE_CHECK_KIND(isCell); }
1255
1257 Cell(const ItemInternalPtr* internals,Int32 local_id)
1258 : ItemWithNodes(internals,local_id)
1259 { ARCANE_CHECK_KIND(isCell); }
1260
1263 {
1264 _set(ainternal);
1265 return (*this);
1266 }
1267
1268 public:
1269
1271 CellLocalId itemLocalId() const { return CellLocalId{ m_local_id }; }
1272
1274 Int32 nbFace() const { return _nbFace(); }
1275
1277 Face face(Int32 i) const { return _face(i); }
1278
1280 FaceConnectedListViewType faces() const { return _faceList(); }
1281
1283 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
1284
1286 FaceLocalIdView faceIds() const { return _faceIds(); }
1287
1289 Int32 nbEdge() const { return _nbEdge(); }
1290
1292 Edge edge(Int32 i) const { return _edge(i); }
1293
1295 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
1296
1298 EdgeConnectedListViewType edges() const { return _edgeList(); }
1299
1301 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
1302
1309 Cell hParent() const { return Cell(_hParentBase(0)); }
1310
1312 Int32 nbHParent() const { return _nbHParent(); }
1313
1315 Int32 nbHChildren() const { return _nbHChildren(); }
1316
1318 Cell hChild(Int32 i) const { return Cell(_hChildBase(i)); }
1319
1321 Cell topHParent() const { return Cell(_toItemBase().topHParentBase()); }
1322
1328 bool isActive() const { return _toItemBase().isActive(); }
1329
1330 bool isSubactive() const { return _toItemBase().isSubactive(); }
1331
1337 bool isAncestor() const { return _toItemBase().isAncestor(); }
1338
1343 bool hasHChildren() const { return _toItemBase().hasHChildren(); }
1344
1350 Int32 level() const
1351 {
1355 if (this->_nbHParent() == 0)
1356 return 0;
1358 return (this->_hParentBase(0).level() + 1);
1359 }
1360
1367 {
1368 return _toItemBase().whichChildAmI(iitem->localId());
1369 }
1370
1376 Int32 whichChildAmI(CellLocalId local_id) const
1377 {
1378 return _toItemBase().whichChildAmI(local_id);
1379 }
1380
1381 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1382 Cell* operator->() { return this; }
1383
1384 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1385 const Cell* operator->() const { return this; }
1386};
1387
1388/*---------------------------------------------------------------------------*/
1389/*---------------------------------------------------------------------------*/
1390
1391inline Cell Item::
1392_cell(Int32 index) const
1393{
1394 return Cell(_connectivity()->cellBase(m_local_id,index));
1395}
1396
1397/*---------------------------------------------------------------------------*/
1398/*---------------------------------------------------------------------------*/
1404: public Item
1405{
1406 using ThatClass = Particle;
1407 // Pour accéder aux constructeurs privés
1408 friend class ItemEnumeratorBaseT<ThatClass>;
1409 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1410 friend class ItemVectorT<ThatClass>;
1411 friend class ItemVectorViewT<ThatClass>;
1412 friend class ItemConnectedListViewT<ThatClass>;
1413 friend class ItemVectorViewConstIteratorT<ThatClass>;
1414 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1415 friend class SimdItemT<ThatClass>;
1416 friend class ItemInfoListViewT<ThatClass>;
1417 friend class ItemLocalIdToItemConverterT<ThatClass>;
1418
1419 private:
1420
1422 Particle(Int32 local_id,ItemSharedInfo* shared_info)
1423 : Item(local_id,shared_info) {}
1424
1425 public:
1426
1428 typedef ParticleLocalId LocalIdType;
1429
1431 Particle() = default;
1432
1434 Particle(ItemInternal* ainternal) : Item(ainternal)
1435 { ARCANE_CHECK_KIND(isParticle); }
1436
1438 Particle(const ItemBase& abase) : Item(abase)
1439 { ARCANE_CHECK_KIND(isParticle); }
1440
1442 explicit Particle(const Item& aitem) : Item(aitem)
1443 { ARCANE_CHECK_KIND(isParticle); }
1444
1446 Particle(const ItemInternalPtr* internals,Int32 local_id)
1447 : Item(internals,local_id)
1448 { ARCANE_CHECK_KIND(isParticle); }
1449
1452 {
1453 _set(ainternal);
1454 return (*this);
1455 }
1456
1457 public:
1458
1460 ParticleLocalId itemLocalId() const { return ParticleLocalId{ m_local_id }; }
1461
1467 Cell cell() const { return _cell(0); }
1468
1470 CellLocalId cellId() const { return _cellId(0); }
1471
1473 bool hasCell() const { return (_cellId(0).localId()!=NULL_ITEM_LOCAL_ID); }
1474
1481 {
1482 Int32 cell_local_id = _cellId(0).localId();
1483 if (cell_local_id==NULL_ITEM_LOCAL_ID)
1484 return Cell();
1485 return _cell(0);
1486 }
1487
1488 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1489 Particle* operator->() { return this; }
1490
1491 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1492 const Particle* operator->() const { return this; }
1493};
1494
1495/*---------------------------------------------------------------------------*/
1496/*---------------------------------------------------------------------------*/
1509class DoF
1510: public Item
1511{
1512 using ThatClass = DoF;
1513 // Pour accéder aux constructeurs privés
1514 friend class ItemEnumeratorBaseT<ThatClass>;
1515 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1516 friend class ItemVectorT<ThatClass>;
1517 friend class ItemVectorViewT<ThatClass>;
1518 friend class ItemConnectedListViewT<ThatClass>;
1519 friend class ItemVectorViewConstIteratorT<ThatClass>;
1520 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1521 friend class SimdItemT<ThatClass>;
1522 friend class ItemInfoListViewT<ThatClass>;
1523 friend class ItemLocalIdToItemConverterT<ThatClass>;
1524
1525 private:
1526
1528 DoF(Int32 local_id,ItemSharedInfo* shared_info)
1529 : Item(local_id,shared_info) {}
1530
1531
1532 public:
1533
1534 using LocalIdType = DoFLocalId;
1535
1537 DoF() = default;
1538
1540 DoF(ItemInternal* ainternal) : Item(ainternal)
1541 { ARCANE_CHECK_KIND(isDoF); }
1542
1544 DoF(const ItemBase& abase) : Item(abase)
1545 { ARCANE_CHECK_KIND(isDoF); }
1546
1548 explicit DoF(const Item& aitem) : Item(aitem)
1549 { ARCANE_CHECK_KIND(isDoF); }
1550
1552 DoF(const ItemInternalPtr* internals,Int32 local_id)
1553 : Item(internals,local_id)
1554 { ARCANE_CHECK_KIND(isDoF); }
1555
1558 {
1559 _set(ainternal);
1560 return (*this);
1561 }
1562
1563 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1564 DoF* operator->() { return this; }
1565
1566 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1567 const DoF* operator->() const { return this; }
1568
1570 DoFLocalId itemLocalId() const { return DoFLocalId{ m_local_id }; }
1571};
1572
1573/*---------------------------------------------------------------------------*/
1574/*---------------------------------------------------------------------------*/
1575
1576/*---------------------------------------------------------------------------*/
1577/*---------------------------------------------------------------------------*/
1578
1580edge(Int32 i) const
1581{
1582 return _edge(i);
1583}
1584
1586face(Int32 i) const
1587{
1588 return _face(i);
1589}
1590
1592cell(Int32 i) const
1593{
1594 return _cell(i);
1595}
1596
1597/*---------------------------------------------------------------------------*/
1598/*---------------------------------------------------------------------------*/
1599
1601face(Int32 i) const
1602{
1603 return _face(i);
1604}
1605
1607cell(Int32 i) const
1608{
1609 return _cell(i);
1610}
1611
1612/*---------------------------------------------------------------------------*/
1613/*---------------------------------------------------------------------------*/
1614
1616boundaryCell() const
1617{
1618 return Cell(_toItemBase().boundaryCell());
1619}
1620
1622backCell() const
1623{
1624 return Cell(_toItemBase().backCell());
1625}
1626
1628frontCell() const
1629{
1630 return Cell(_toItemBase().frontCell());
1631}
1632
1634oppositeCell(Cell cell) const
1635{
1636 ARCANE_ASSERT((backCell()==cell || frontCell()==cell),("cell is not connected to the face"));
1637 return (backCell()==cell) ? frontCell() : backCell();
1638}
1639
1641cell(Int32 i) const
1642{
1643 return _cell(i);
1644}
1645
1646/*---------------------------------------------------------------------------*/
1647/*---------------------------------------------------------------------------*/
1648
1650toItemWithNodes() const
1651{
1652 ARCANE_CHECK_KIND(isItemWithNodes);
1653 return ItemWithNodes(*this);
1654}
1655
1657toNode() const
1658{
1659 ARCANE_CHECK_KIND(isNode);
1660 return Node(*this);
1661}
1662
1664toEdge() const
1665{
1666 ARCANE_CHECK_KIND(isEdge);
1667 return Edge(*this);
1668}
1669
1671toFace() const
1672{
1673 ARCANE_CHECK_KIND(isFace);
1674 return Face(*this);
1675}
1676
1678toCell() const
1679{
1680 ARCANE_CHECK_KIND(isCell);
1681 return Cell(*this);
1682}
1683
1685toParticle() const
1686{
1687 ARCANE_CHECK_KIND(isParticle);
1688 return Particle(*this);
1689}
1690
1692toDoF() const
1693{
1694 ARCANE_CHECK_KIND(isDoF);
1695 return DoF(*this);
1696}
1697
1698/*---------------------------------------------------------------------------*/
1699/*---------------------------------------------------------------------------*/
1700
1701inline ItemLocalId::
1702ItemLocalId(Item item)
1703: m_local_id(item.localId())
1704{
1705}
1706
1707template<typename ItemType> inline ItemLocalIdT<ItemType>::
1708ItemLocalIdT(ItemType item)
1709: ItemLocalId(item.localId())
1710{
1711}
1712
1713/*---------------------------------------------------------------------------*/
1714/*---------------------------------------------------------------------------*/
1715
1717operator[](ItemLocalId local_id) const
1718{
1719 return Item(local_id.localId(), m_item_shared_info);
1720}
1721
1722/*---------------------------------------------------------------------------*/
1723/*---------------------------------------------------------------------------*/
1724
1726operator[](Int32 local_id) const
1727{
1728 return Item(local_id, m_item_shared_info);
1729}
1730
1731/*---------------------------------------------------------------------------*/
1732/*---------------------------------------------------------------------------*/
1733
1734template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
1735operator[](ItemLocalId local_id) const
1736{
1737 return ItemType(local_id.localId(), m_item_shared_info);
1738}
1739
1740/*---------------------------------------------------------------------------*/
1741/*---------------------------------------------------------------------------*/
1742
1743template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
1744operator[](Int32 local_id) const
1745{
1746 return ItemType(local_id, m_item_shared_info);
1747}
1748
1749/*---------------------------------------------------------------------------*/
1750/*---------------------------------------------------------------------------*/
1751
1752inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
1753operator[](ItemLocalId local_id) const
1754{
1755 return Item(local_id.localId(), m_item_shared_info);
1756}
1757
1758/*---------------------------------------------------------------------------*/
1759/*---------------------------------------------------------------------------*/
1760
1761inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
1762operator[](Int32 local_id) const
1763{
1764 return Item(local_id, m_item_shared_info);
1765}
1766
1767/*---------------------------------------------------------------------------*/
1768/*---------------------------------------------------------------------------*/
1769
1770template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
1772operator[](ItemLocalIdType local_id) const
1773{
1774 return ItemType(local_id.localId(), m_item_shared_info);
1775}
1776
1777/*---------------------------------------------------------------------------*/
1778/*---------------------------------------------------------------------------*/
1779
1780template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
1782operator[](Int32 local_id) const
1783{
1784 return ItemType(local_id, m_item_shared_info);
1785}
1786
1787/*---------------------------------------------------------------------------*/
1788/*---------------------------------------------------------------------------*/
1789
1790} // End namespace Arcane
1791
1792/*---------------------------------------------------------------------------*/
1793/*---------------------------------------------------------------------------*/
1794
1795#include "arcane/ItemCompatibility.h"
1796
1797/*---------------------------------------------------------------------------*/
1798/*---------------------------------------------------------------------------*/
1799
1800#endif
Déclarations de types sur les entités.
Maille d'un maillage.
Definition Item.h:1199
Cell topHParent() const
parent de niveau 0 pour l'AMR
Definition Item.h:1321
Int32 nbEdge() const
Nombre d'arêtes de la maille.
Definition Item.h:1289
Cell(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1253
FaceConnectedListViewType faces() const
Liste des faces de la maille.
Definition Item.h:1280
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition Item.h:1315
bool isAncestor() const
Definition Item.h:1337
Cell(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1233
Face face(Int32 i) const
i-ème face de la maille
Definition Item.h:1277
FaceLocalIdView faceIds() const
Liste des faces de la maille.
Definition Item.h:1286
Cell(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1245
Int32 nbFace() const
Nombre de faces de la maille.
Definition Item.h:1274
Cell & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1262
Cell(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1257
CellLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1271
EdgeLocalIdView edgeIds() const
Liste des arêtes de la maille.
Definition Item.h:1301
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la maille
Definition Item.h:1295
Int32 whichChildAmI(const ItemInternal *iitem) const
Definition Item.h:1366
Cell hChild(Int32 i) const
i-ème enfant AMR
Definition Item.h:1318
bool hasHChildren() const
Definition Item.h:1343
Cell(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1249
Edge edge(Int32 i) const
i-ème arête de la maille
Definition Item.h:1292
Cell()=default
Constructeur d'une maille nulle.
Int32 whichChildAmI(CellLocalId local_id) const
Definition Item.h:1376
FaceLocalId faceId(Int32 i) const
i-ème face de la maille
Definition Item.h:1283
bool isActive() const
Definition Item.h:1328
Int32 level() const
Definition Item.h:1350
Cell hParent() const
Definition Item.h:1309
EdgeConnectedListViewType edges() const
Liste des arêtes de la maille.
Definition Item.h:1298
Int32 nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:1312
CellLocalId LocalIdType
Type du localId()
Definition Item.h:1239
classe degré de liberté.
Definition Item.h:1511
DoF(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1552
DoF()=default
Constructeur d'une maille non connectée.
DoF(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1544
DoF(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:1548
DoFLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1570
DoF & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1557
DoF(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1540
DoF(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1528
Arête d'une maille.
Definition Item.h:817
FaceConnectedListViewType faces() const
Liste des faces de l'arête.
Definition Item.h:916
CellConnectedListViewType cells() const
Liste des mailles de l'arête.
Definition Item.h:904
Cell cell(Int32 i) const
i-ème maille de l'arête
Definition Item.h:1607
Edge(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:867
Face face(Int32 i) const
i-ème face de l'arête
Definition Item.h:1601
Edge(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:875
FaceLocalIdView faceIds() const
Liste des faces de l'arête.
Definition Item.h:922
Edge & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:880
Int32 nbFace() const
Nombre de faces connectées à l'arête.
Definition Item.h:895
CellLocalIdView cellIds() const
Liste des mailles de l'arête.
Definition Item.h:910
Edge(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:871
Edge()=default
Créé une arête nulle.
FaceLocalId faceId(Int32 i) const
i-ème face de l'arête
Definition Item.h:919
Edge(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:863
EdgeLocalId LocalIdType
Type du localId()
Definition Item.h:857
Edge(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:851
Int32 nbNode() const
Nombre de sommets de l'arête.
Definition Item.h:892
CellLocalId cellId(Int32 i) const
i-ème maille de l'arête
Definition Item.h:907
Int32 nbCell() const
Nombre de mailles connectées à l'arête.
Definition Item.h:898
EdgeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:889
Face d'une maille.
Definition Item.h:952
Face()=default
Création d'une face non connecté au maillage.
bool isMasterFace() const
true s'il s'agit de la face maître d'une interface
Definition Item.h:1114
FaceLocalId LocalIdType
Type du localId()
Definition Item.h:992
CellLocalId frontCellId() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1083
Face(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1002
Cell frontCell() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1628
CellLocalId cellId(Int32 i) const
i-ème maille de la face
Definition Item.h:1036
EdgeLocalIdView edgeIds() const
Liste des arêtes de la face.
Definition Item.h:1150
Cell cell(Int32 i) const
i-ème maille de la face
Definition Item.h:1641
Int32 nbCell() const
Nombre de mailles de la face (1 ou 2)
Definition Item.h:1027
ARCANE_DEPRECATED_118 bool isBoundary() const
Definition Item.h:1052
FaceConnectedListViewType slaveFaces() const
Liste des faces esclaves associées à cette face maître.
Definition Item.h:1128
ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1065
EdgeConnectedListViewType edges() const
Liste des arêtes de la face.
Definition Item.h:1144
bool isSubDomainBoundary() const
Indique si la face est au bord du sous-domaine (i.e nbCell()==1)
Definition Item.h:1046
Face(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1006
FaceLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1024
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la face
Definition Item.h:1147
CellConnectedListViewType cells() const
Liste des mailles de la face.
Definition Item.h:1033
Face masterFace() const
Face maître associée à cette face.
Definition Item.h:1111
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Definition Item.h:1117
Edge edge(Int32 i) const
i-ème arête de la face
Definition Item.h:1141
CellLocalId backCellId() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1077
Face(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1010
bool isSubDomainBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1055
Face(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:998
Cell boundaryCell() const
Maille associée à cette face frontière (maille nulle si aucune)
Definition Item.h:1616
Int32 nbEdge() const
Nombre d'arêtes de la face.
Definition Item.h:1138
bool isTiedFace() const
true s'il s'agit d'une face esclave ou maître d'une interface
Definition Item.h:1120
Face(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:986
CellLocalIdView cellIds() const
Liste des mailles de la face.
Definition Item.h:1039
Face & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1015
Cell backCell() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1622
Cell oppositeCell(Cell cell) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1634
CellLocalId oppositeCellId(CellLocalId cell_id) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1097
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Classe de base pour les entités du maillage.
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
ItemSharedInfo * m_shared_info
Infos partagées entre toutes les entités ayant les mêmes caractéristiques.
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Classe de base typeé des énumérateurs sur une liste d'entité connectées.
Vue sur une liste d'entités connectées à une autre.
Classe de base des énumérateurs sur une liste d'entité.
@ II_Shared
L'entité est partagée par un autre sous-domaine.
Definition ItemFlags.h:51
@ II_HasBackCell
L'entité a une maille derrière.
Definition ItemFlags.h:45
@ II_Own
L'entité est une entité propre au sous-domaine.
Definition ItemFlags.h:48
@ II_Boundary
L'entité est sur la frontière.
Definition ItemFlags.h:43
Classe de base des vues spécialisées des informations sur les entités.
ItemType operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1735
Item operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1717
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Structure interne d'une entité de maillage.
Classe pour convertir un ItemLocalId vers une entité (Item).
constexpr __host__ __device__ ItemType operator[](ItemLocalIdType local_id) const
Entité de numéro local local_id.
Definition Item.h:1772
constexpr __host__ __device__ Item operator[](ItemLocalId local_id) const
Entité de numéro local local_id.
Definition Item.h:1753
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Structure interne partagée d'une entité de maillage.
ConstArrayView< ItemInternal * > m_items_internal
ItemInternal des entités.
Type d'une entité (Item).
Definition ItemTypeId.h:32
Infos sur un type d'entité du maillage.
Identifiant unique d'une entité.
Vecteur typé d'entité.
Definition ItemVector.h:166
Vue sur un tableau typé d'entités.
Elément de maillage s'appuyant sur des noeuds (Edge,Face,Cell).
Definition Item.h:727
ItemWithNodes(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:765
NodeLocalId nodeId(Int32 index) const
i-ème noeud de l'entité.
Definition Item.h:791
ItemWithNodes(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:757
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:782
ItemWithNodes(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:744
ItemWithNodes(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:761
Int32 nbLinearNode() const
Nombre de noeuds de l'entité linéaire associée (si entité ordre 2 ou plus)
Definition Item.h:794
NodeConnectedListViewType nodes() const
Liste des noeuds de l'entité
Definition Item.h:785
ItemWithNodes(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:753
ItemWithNodes()=default
Création d'une entité non connectée au maillage.
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:779
NodeLocalIdView nodeIds() const
Liste des noeuds de l'entité
Definition Item.h:788
ItemWithNodes & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:770
Index d'un Item dans une variable.
Definition Item.h:119
Classe de base d'un élément de maillage.
Definition Item.h:83
Int32 nbParent() const
Nombre de parents pour les sous-maillages.
Definition Item.h:283
const ItemTypeInfo * typeInfo() const
Infos sur le type de l'entité.
Definition Item.h:386
impl::MutableItemBase mutableItemBase() const
Partie interne modifiable de l'entité.
Definition Item.h:374
Int32 _nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:441
static const Int32 NULL_ELEMENT
Indice d'un élément nul.
Definition Item.h:163
bool isItemWithNodes() const
true si l'entité est du genre ItemWithNodes.
Definition Item.h:294
Item(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:182
Integer _nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
Definition Item.h:435
Integer _nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:433
ItemInternal * internal() const
Partie interne de l'entité.
Definition Item.h:348
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:219
Edge toEdge() const
Converti l'entité en le genre Edge.
Definition Item.h:1664
Item(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:200
Item()=default
Création d'une entité de maillage nulle.
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253
static String typeName(Int32 type)
Nom du type de maille cell_type.
Definition Item.cc:51
bool isCell() const
true si l'entité est du genre Cell.
Definition Item.h:307
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:238
ItemSharedInfo * m_shared_info
Infos partagées entre toutes les entités ayant les mêmes caractéristiques.
Definition Item.h:399
ItemLocalId LocalIdType
Type du localId()
Definition Item.h:108
Integer _nbFace() const
Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
Definition Item.h:437
ItemWithNodes toItemWithNodes() const
Converti l'entité en le genre ItemWithNodes.
Definition Item.h:1650
DoF toDoF() const
Converti l'entité en le genre DoF.
Definition Item.h:1692
Cell toCell() const
Converti l'entité en le genre Cell.
Definition Item.h:1678
eItemKind kind() const
Genre de l'entité
Definition Item.h:250
@ Tri3
Elément de type triangle (3 sommets, 2D)
Definition Item.h:149
@ Quad4
Elément de type quad (4 sommets, 2D)
Definition Item.h:150
@ Pentagon5
Elément de type pentagone (5 sommets, 2D)
Definition Item.h:151
@ Unknown
Elément de type nul.
Definition Item.h:146
@ Pyramid
Elément de type pyramide (5 sommets, 3D)
Definition Item.h:154
@ Bar2
Elément de type arête (2 sommets, 1D, 2D et 3D)
Definition Item.h:148
@ Vertex
Elément de type noeud (1 sommet 1D, 2D et 3D)
Definition Item.h:147
@ Hexa
Elément de type hexaèdre (8 sommets, 3D)
Definition Item.h:156
@ Hexagon6
Elément de type hexagone (6 sommets, 2D)
Definition Item.h:152
@ Penta
Elément de type pentaèdre (6 sommets, 3D)
Definition Item.h:155
@ Wedge8
Elément de type prisme à 8 faces (base hexagonale)
Definition Item.h:158
@ Wedge7
Elément de type prisme à 7 faces (base pentagonale)
Definition Item.h:157
@ Tetra
Elément de type tétraédre (4 sommets, 3D)
Definition Item.h:153
IItemFamily * itemFamily() const
Famille dont est issue l'entité
Definition Item.h:247
Particle toParticle() const
Converti l'entité en le genre Particle.
Definition Item.h:1685
constexpr __host__ __device__ Item(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:193
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225
constexpr __host__ __device__ Item(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:172
constexpr bool null() const
true si l'entité est nul (i.e. non connecté au maillage)
Definition Item.h:216
Int32 _flags() const
Flags de l'entité
Definition Item.h:431
constexpr ItemLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:222
bool isFace() const
true si l'entité est du genre Edge.
Definition Item.h:319
Face toFace() const
Converti l'entité en le genre Edge.
Definition Item.h:1671
bool isNode() const
true si l'entité est du genre Node.
Definition Item.h:301
Integer _nbParent() const
Nombre de parent pour les sous-maillages.
Definition Item.h:445
Integer _nbCell() const
Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
Definition Item.h:439
bool isEdge() const
true si l'entité est du genre Edge.
Definition Item.h:313
Item parent(Int32 i) const
i-ème parent pour les sous-maillages
Definition Item.h:286
ItemTypeId itemTypeId() const
Type de l'entité
Definition Item.h:244
Item parent() const
premier parent pour les sous-maillages
Definition Item.h:289
bool isDoF() const
true is l'entité est du genre DoF
Definition Item.h:331
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
Definition Item.h:409
impl::ItemBase itemBase() const
Partie interne de l'entité.
Definition Item.h:363
bool isShared() const
Vrai si l'entité est partagé d'autres sous-domaines.
Definition Item.h:265
bool isParticle() const
true is l'entité est du genre Particle.
Definition Item.h:325
Int32 _nbHChildren() const
Nombre d' enfants pour l'AMR.
Definition Item.h:443
Int16 type() const
Type de l'entité
Definition Item.h:241
Int32 _nbLinearNode() const
Nombre de noeuds de l'entité
Definition Item.h:471
Item & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:207
Node toNode() const
Converti l'entité en le genre Node.
Definition Item.h:1657
Noeud d'un maillage.
Definition Item.h:576
Cell cell(Int32 i) const
i-ème maille du noeud
Definition Item.h:1592
FaceLocalIdView faceIds() const
Liste des faces du noeud.
Definition Item.h:689
Node(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:634
CellConnectedListViewType cells() const
Liste des mailles du noeud.
Definition Item.h:683
CellVectorView _internalActiveCells(Int32Array &local_ids) const
Enumére les mailles connectées au noeud.
Definition Item.h:697
Node(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:622
EdgeLocalIdView edgeIds() const
Liste des arêtes du noeud.
Definition Item.h:686
Node(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:610
NodeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:647
Node(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:630
FaceLocalId faceId(Int32 i) const
i-ème face du noeud
Definition Item.h:671
FaceConnectedListViewType faces() const
Liste des faces du noeud.
Definition Item.h:680
Node & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:638
Face face(Int32 i) const
i-ème face du noeud
Definition Item.h:1586
Int32 nbEdge() const
Nombre d'arêtes connectées au noeud.
Definition Item.h:650
Node(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:626
CellLocalIdView cellIds() const
Liste des mailles du noeud.
Definition Item.h:692
Edge edge(Int32 i) const
i-ème arête du noeud
Definition Item.h:1580
Int32 nbFace() const
Nombre de faces connectées au noeud.
Definition Item.h:653
Int32 nbCell() const
Nombre de mailles connectées au noeud.
Definition Item.h:656
EdgeConnectedListViewType edges() const
Liste des arêtes du noeud.
Definition Item.h:677
CellLocalId cellId(Int32 i) const
i-ème maille du noeud
Definition Item.h:674
EdgeLocalId edgeId(Int32 i) const
i-ème arête du noeud
Definition Item.h:668
NodeLocalId LocalIdType
Type du localId()
Definition Item.h:616
Particule.
Definition Item.h:1405
Particle(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1438
Particle()=default
Constructeur d'une particule nulle.
bool hasCell() const
Vrai si la particule est dans une maille du maillage.
Definition Item.h:1473
Particle(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1422
ParticleLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1460
Cell cell() const
Maille à laquelle appartient la particule. Il faut appeler setCell() avant d'appeler cette fonction....
Definition Item.h:1467
CellLocalId cellId() const
Maille connectée à la particule.
Definition Item.h:1470
Particle(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1446
Cell cellOrNull() const
Maille à laquelle appartient la particule ou maille nulle. Retourne cell() si la particule est dans u...
Definition Item.h:1480
Particle & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1451
ParticleLocalId LocalIdType
Type du localId()
Definition Item.h:1428
Particle(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1442
Particle(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1434
Gère un vecteur d'entité ItemType.
Definition SimdItem.h:236
Chaîne de caractères unicode.
ItemLocalIdListViewT< Node > NodeLocalIdView
Vue sur les localId() d'une liste de noeuds.
Definition ItemTypes.h:407
ItemVectorViewT< Cell > CellVectorView
Vue sur un vecteur de mailles.
Definition ItemTypes.h:304
ItemLocalIdListViewT< Edge > EdgeLocalIdView
Vue sur les localId() d'une liste d'arêtes.
Definition ItemTypes.h:417
ItemLocalIdListViewT< Face > FaceLocalIdView
Vue sur les localId() d'une liste de faces.
Definition ItemTypes.h:427
ItemLocalIdListViewT< Cell > CellLocalIdView
Vue sur les localId() d'une liste de mailles.
Definition ItemTypes.h:437
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
NodeConnectedListView NodeConnectedListViewType
Liste de noeuds connectés.
Definition ItemTypes.h:349
Int32 Integer
Type représentant un entier.
CellConnectedListView CellConnectedListViewType
Liste de mailles connectées.
Definition ItemTypes.h:355
bool operator<(const Item &item1, const Item &item2)
Compare deux entités.
Definition Item.h:545
eItemKind
Genre d'entité de maillage.
@ IK_Particle
Entité de maillage de genre particule.
@ IK_Node
Entité de maillage de genre noeud.
@ IK_Cell
Entité de maillage de genre maille.
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
@ IK_Face
Entité de maillage de genre face.
@ IK_DoF
Entité de maillage de genre degre de liberte.
@ IK_Edge
Entité de maillage de genre arête.
std::int16_t Int16
Type entier signé sur 16 bits.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
EdgeConnectedListView EdgeConnectedListViewType
Liste d'arêtes connectées.
Definition ItemTypes.h:351
FaceConnectedListView FaceConnectedListViewType
Liste de faces connectées.
Definition ItemTypes.h:353
@ Cell
Le maillage est AMR par maille.
Definition MeshKind.h:52
std::int32_t Int32
Type entier signé sur 32 bits.