Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemInternal.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/*---------------------------------------------------------------------------*/
8/* ItemInternal.h (C) 2000-2024 */
9/* */
10/* Partie interne d'une entité. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ITEMINTERNAL_H
13#define ARCANE_CORE_ITEMINTERNAL_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Array.h"
18
19#include "arcane/core/ItemTypes.h"
20#include "arcane/core/ItemIndexedListView.h"
21#include "arcane/core/ItemSharedInfo.h"
22#include "arcane/core/ItemUniqueId.h"
23#include "arcane/core/ItemLocalIdListView.h"
24#include "arcane/core/ItemTypeId.h"
25#include "arcane/core/ItemFlags.h"
26#include "arcane/core/ItemConnectivityContainerView.h"
27#include "arcane/core/ItemInternalVectorView.h"
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32#ifdef null
33#undef null
34#endif
35
36//#define ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO
37
38#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO
39#define A_INTERNAL_SI(name) m_shared_infos.m_##name
40#else
41#define A_INTERNAL_SI(name) m_items->m_##name##_shared_info
42#endif
43
44/*---------------------------------------------------------------------------*/
45/*---------------------------------------------------------------------------*/
46
47namespace Arcane::mesh
48{
49class IncrementalItemConnectivityBase;
50class PolyhedralFamily;
51class PolyhedralMeshImpl;
52class FaceFamily;
53class MeshRefinement;
54}
55namespace Arcane::Materials
56{
57class ComponentItemSharedInfo;
58}
59namespace Arcane
60{
61class ItemInternalCompatibility;
62
63/*---------------------------------------------------------------------------*/
64/*---------------------------------------------------------------------------*/
69class ARCANE_CORE_EXPORT ItemBaseBuildInfo
70{
71 public:
72 ItemBaseBuildInfo() = default;
73 ItemBaseBuildInfo(Int32 local_id,ItemSharedInfo* shared_info)
74 : m_local_id(local_id), m_shared_info(shared_info) {}
75 public:
76 Int32 m_local_id = NULL_ITEM_LOCAL_ID;
77 ItemSharedInfo* m_shared_info = nullptr;
78};
79
80/*---------------------------------------------------------------------------*/
81/*---------------------------------------------------------------------------*/
88class ARCANE_CORE_EXPORT ItemInternalConnectivityList
89{
90 // IMPORTANT: Cette structure doit avoir le même agencement mémoire
91 // que la structure C# de même nom.
92
93 friend class ItemBase;
94 friend class ItemInternal;
95 friend class Item;
96
97 // Pour accès à _setConnectivity*
98 friend mesh::IncrementalItemConnectivityBase;
99 friend mesh::PolyhedralFamily;
100 friend mesh::PolyhedralMeshImpl;
101
102 // Pour accès à m_items
103 friend mesh::ItemFamily;
104
105 private:
106
114 struct Int32View
115 {
116 public:
117 Int32 operator[](Int32 index) const
118 {
119#ifdef ARCANE_CHECK
120 if (index==NULL_ITEM_LOCAL_ID){
121 // Pour l'entité nulle, la taille doit être 0.
122 if (m_size!=0)
123 arcaneRangeError(index,m_size);
124 }
125 else
126 ARCANE_CHECK_AT(index,m_size);
127#endif
128 return m_data[index];
129 }
130 void operator=(ConstArrayView<Int32> v)
131 {
132 m_data = v.data();
133 m_size = v.size();
134 }
135 // Il faut que data[NULL_ITEM_LOCAL_ID] soit valide.
136 // Il faut donc que (data-1) pointe vers une adresse valide
137 void setNull(const Int32* data)
138 {
139 m_data = data;
140 m_size = 0;
141 }
142 operator ConstArrayView<Int32>() const
143 {
144 return ConstArrayView<Int32>(m_size,m_data);
145 }
146 operator SmallSpan<const Int32>() const
147 {
148 return SmallSpan<const Int32>(m_data,m_size);
149 }
150 private:
151 Int32 m_size;
152 const Int32* m_data;
153 };
154
155 public:
156
157 enum
158 {
159 NODE_IDX = 0,
160 EDGE_IDX = 1,
161 FACE_IDX = 2,
162 CELL_IDX = 3,
163 HPARENT_IDX = 4,
164 HCHILD_IDX = 5,
165 MAX_ITEM_KIND = 6
166 };
167
168 public:
169
170 static ItemInternalConnectivityList nullInstance;
171
172 public:
173
174 ItemInternalConnectivityList()
175 : m_items(nullptr)
176 {
177 for( Integer i=0; i<MAX_ITEM_KIND; ++i ){
178 m_kind_info[i].m_nb_item_null_data[0] = 0;
179 m_kind_info[i].m_nb_item_null_data[1] = 0;
180 m_kind_info[i].m_max_nb_item = 0;
181 }
182
183 for( Integer i=0; i<MAX_ITEM_KIND; ++i ){
184 m_container[i].m_nb_item.setNull(&m_kind_info[i].m_nb_item_null_data[1]);
185 m_container[i].m_offset = ConstArrayView<Int32>{};
186 }
187 }
188
189 public:
190
191 void updateMeshItemInternalList()
192 {
193#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO
194 m_shared_infos.m_node = m_items->m_node_shared_info;
195 m_shared_infos.m_edge = m_items->m_edge_shared_info;
196 m_shared_infos.m_face = m_items->m_face_shared_info;
197 m_shared_infos.m_cell = m_items->m_cell_shared_info;
198#endif
199 }
200
201 private:
202
207 Int32 itemLocalId(Int32 item_kind,Int32 lid,Integer index) const
208 {
209 return m_container[item_kind].itemLocalId(lid,index);
210 }
212 Int64 nbAccess() const { return 0; }
214 Int64 nbAccessAll() const { return 0; }
215
216 private:
217
219 void _setConnectivityIndex(Int32 item_kind,ConstArrayView<Int32> v)
220 {
221 m_container[item_kind].m_indexes = v;
222 }
224 void _setConnectivityList(Int32 item_kind,ConstArrayView<Int32> v)
225 {
226 m_container[item_kind].m_list = v;
227 m_container[item_kind].m_offset = ConstArrayView<Int32>{};
228 }
230 void _setConnectivityNbItem(Int32 item_kind,ConstArrayView<Int32> v)
231 {
232 m_container[item_kind].m_nb_item = v;
233 }
235 void _setMaxNbConnectedItem(Int32 item_kind,Int32 v)
236 {
237 m_kind_info[item_kind].m_max_nb_item = v;
238 }
239
240 public:
241
243 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
244 Int32ConstArrayView connectivityIndex(Int32 item_kind) const
245 {
246 return m_container[item_kind].m_indexes;
247 }
249 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
250 Int32ConstArrayView connectivityList(Int32 item_kind) const
251 {
252 return m_container[item_kind].m_list;
253 }
255 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
256 Int32ConstArrayView connectivityNbItem(Int32 item_kind) const
257 {
258 return m_container[item_kind].m_nb_item;
259 }
260
261 public:
262
264 Int32 maxNbConnectedItem(Int32 item_kind) const
265 {
266 return m_kind_info[item_kind].m_max_nb_item;
267 }
268
269 ItemConnectivityContainerView containerView(Int32 item_kind) const
270 {
271 return m_container[item_kind].containerView();
272 }
273
274 public:
275
276 ItemBaseBuildInfo nodeBase(Int32 lid,Int32 aindex) const
277 { return ItemBaseBuildInfo(_nodeLocalIdV2(lid,aindex),A_INTERNAL_SI(node)); }
278 ItemBaseBuildInfo edgeBase(Int32 lid,Int32 aindex) const
279 { return ItemBaseBuildInfo(_edgeLocalIdV2(lid,aindex),A_INTERNAL_SI(edge)); }
280 ItemBaseBuildInfo faceBase(Int32 lid,Int32 aindex) const
281 { return ItemBaseBuildInfo(_faceLocalIdV2(lid,aindex),A_INTERNAL_SI(face)); }
282 ItemBaseBuildInfo cellBase(Int32 lid,Int32 aindex) const
283 { return ItemBaseBuildInfo(_cellLocalIdV2(lid,aindex),A_INTERNAL_SI(cell)); }
284 ItemBaseBuildInfo hParentBase(Int32 lid, Int32 aindex, ItemSharedInfo* isf) const
285 {
286 return ItemBaseBuildInfo(_hParentLocalIdV2(lid, aindex), isf);
287 }
288 ItemBaseBuildInfo hChildBase(Int32 lid, Int32 aindex, ItemSharedInfo* isf) const
289 {
290 return ItemBaseBuildInfo(_hChildLocalIdV2(lid, aindex), isf);
291 }
292
293 auto nodeList(Int32 lid) const { return impl::ItemIndexedListView { A_INTERNAL_SI(node),_itemLocalIdListView(NODE_IDX,lid) }; }
294 auto edgeList(Int32 lid) const { return impl::ItemIndexedListView { A_INTERNAL_SI(edge),_itemLocalIdListView(EDGE_IDX,lid) }; }
295 auto faceList(Int32 lid) const { return impl::ItemIndexedListView { A_INTERNAL_SI(face),_itemLocalIdListView(FACE_IDX,lid) }; }
296 auto cellList(Int32 lid) const { return impl::ItemIndexedListView { A_INTERNAL_SI(cell),_itemLocalIdListView(CELL_IDX,lid) }; }
297
298 private:
299
300 // Ces 4 méthodes sont encore utilisées par ItemBase via internalNodes(), internalEdges(), ...
301 // On pourra les supprimer quand ces méthodes obsolètes seront supprimées
302 ItemInternalVectorView nodesV2(Int32 lid) const { return { A_INTERNAL_SI(node),_itemLocalIdListView(NODE_IDX,lid) }; }
303 ItemInternalVectorView edgesV2(Int32 lid) const { return { A_INTERNAL_SI(edge),_itemLocalIdListView(EDGE_IDX,lid) }; }
304 ItemInternalVectorView facesV2(Int32 lid) const { return { A_INTERNAL_SI(face),_itemLocalIdListView(FACE_IDX,lid) }; }
305 ItemInternalVectorView cellsV2(Int32 lid) const { return { A_INTERNAL_SI(cell),_itemLocalIdListView(CELL_IDX,lid) }; }
306
307 NodeLocalIdView nodeLocalIdsView(Int32 lid) const { return NodeLocalIdView(_itemLocalIdListView(NODE_IDX,lid)); }
308 EdgeLocalIdView edgeLocalIdsView(Int32 lid) const { return EdgeLocalIdView(_itemLocalIdListView(EDGE_IDX,lid)); }
309 FaceLocalIdView faceLocalIdsView(Int32 lid) const { return FaceLocalIdView(_itemLocalIdListView(FACE_IDX,lid)); }
310 CellLocalIdView cellLocalIdsView(Int32 lid) const { return CellLocalIdView(_itemLocalIdListView(CELL_IDX,lid)); }
311
312 private:
313
314 Int32 _nodeLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(NODE_IDX,lid,index); }
315 Int32 _edgeLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(EDGE_IDX,lid,index); }
316 Int32 _faceLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(FACE_IDX,lid,index); }
317 Int32 _cellLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(CELL_IDX,lid,index); }
318 Int32 _hParentLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(HPARENT_IDX,lid,index); }
319 Int32 _hChildLocalIdV2(Int32 lid,Int32 index) const { return itemLocalId(HCHILD_IDX,lid,index); }
320
321 private:
322
323 ItemInternal* _nodeV2(Int32 lid,Int32 aindex) const { return m_items->nodes[ _nodeLocalIdV2(lid,aindex) ]; }
324 ItemInternal* _edgeV2(Int32 lid,Int32 aindex) const { return m_items->edges[ _edgeLocalIdV2(lid,aindex) ]; }
325 ItemInternal* _faceV2(Int32 lid,Int32 aindex) const { return m_items->faces[ _faceLocalIdV2(lid,aindex) ]; }
326 ItemInternal* _cellV2(Int32 lid,Int32 aindex) const { return m_items->cells[ _cellLocalIdV2(lid,aindex) ]; }
327 ItemInternal* _hParentV2(Int32 lid,Int32 aindex) const { return m_items->cells[ _hParentLocalIdV2(lid,aindex) ]; }
328 ItemInternal* _hChildV2(Int32 lid,Int32 aindex) const { return m_items->cells[ _hChildLocalIdV2(lid,aindex) ]; }
329
330 private:
331
332 Int32 _nbNodeV2(Int32 lid) const { return m_container[NODE_IDX].m_nb_item[lid]; }
333 Int32 _nbEdgeV2(Int32 lid) const { return m_container[EDGE_IDX].m_nb_item[lid]; }
334 Int32 _nbFaceV2(Int32 lid) const { return m_container[FACE_IDX].m_nb_item[lid]; }
335 Int32 _nbCellV2(Int32 lid) const { return m_container[CELL_IDX].m_nb_item[lid]; }
336 Int32 _nbHParentV2(Int32 lid) const { return m_container[HPARENT_IDX].m_nb_item[lid]; }
337 Int32 _nbHChildrenV2(Int32 lid) const { return m_container[HCHILD_IDX].m_nb_item[lid]; }
338
339 private:
340
341 Int32 _nodeOffset(Int32 lid) const { return m_container[NODE_IDX].itemOffset(lid); }
342 Int32 _edgeOffset(Int32 lid) const { return m_container[EDGE_IDX].itemOffset(lid); }
343 Int32 _faceOffset(Int32 lid) const { return m_container[FACE_IDX].itemOffset(lid); }
344 Int32 _cellOffset(Int32 lid) const { return m_container[CELL_IDX].itemOffset(lid); }
345 Int32 _itemOffset(Int32 item_kind,Int32 lid) const { return m_container[item_kind].itemOffset(lid); }
346
347 private:
348
349 impl::ItemLocalIdListContainerView _itemLocalIdListView(Int32 item_kind,Int32 lid) const
350 {
351 return m_container[item_kind].itemLocalIdListView(lid);
352 }
353
354 private:
355
356 // NOTE : à terme, il faudra fusionner cette classe avec ItemConnectivityContainerView
358 struct Container
359 {
360 impl::ItemLocalIdListContainerView itemLocalIdListView(Int32 lid) const
361 {
362 return impl::ItemLocalIdListContainerView(itemLocalIdsData(lid),m_nb_item[lid],itemOffset(lid));
363 }
364 const Int32* itemLocalIdsData(Int32 lid) const
365 {
366 return &(m_list[ m_indexes[lid] ]);
367 }
368 Int32 itemLocalId(Int32 lid,Integer index) const
369 {
370 return m_list[ m_indexes[lid] + index] + itemOffset(lid);
371 }
372 ItemConnectivityContainerView containerView() const
373 {
374 return ItemConnectivityContainerView( m_list, m_indexes, m_nb_item );
375 }
376 Int32 itemOffset([[maybe_unused]] Int32 lid) const
377 {
378#ifdef ARCANE_USE_OFFSET_FOR_CONNECTIVITY
379 return m_offset[lid];
380#else
381 return 0;
382#endif
383 }
384
385 public:
386
387 ConstArrayView<Int32> m_indexes;
388 Int32View m_nb_item;
389 ConstArrayView<Int32> m_list;
390 ConstArrayView<Int32> m_offset;
391 };
392
393 struct KindInfo
394 {
395 Int32 m_max_nb_item;
396 Int32 m_nb_item_null_data[2];
397 };
398
399 private:
400
401 Container m_container[MAX_ITEM_KIND];
402 KindInfo m_kind_info[MAX_ITEM_KIND];
403
404 MeshItemInternalList* m_items;
405
406 private:
407
408#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO
409 impl::MeshItemSharedInfoList m_shared_infos;
410#endif
411};
412
413/*---------------------------------------------------------------------------*/
414/*---------------------------------------------------------------------------*/
431class ARCANE_CORE_EXPORT ItemBase
432: public ItemFlags
433{
434 friend class ::Arcane::ItemInternal;
435 friend class ::Arcane::Item;
436 friend class ::Arcane::ItemInternalCompatibility;
437 friend class ::Arcane::Materials::ComponentItemSharedInfo;
438 friend class ::Arcane::ItemEnumerator;
439 friend MutableItemBase;
440 // Pour _internalActiveCells2().
441 friend class ::Arcane::Node;
442 // Pour _itemInternal()
443 friend class ::Arcane::mesh::ItemFamily;
444 friend class ::Arcane::mesh::MeshRefinement;
445
446 private:
447
448 ItemBase(Int32 local_id,ItemSharedInfo* shared_info)
449 : m_local_id(local_id), m_shared_info(shared_info) {}
450
451 public:
452
453 ItemBase() : m_shared_info(ItemSharedInfo::nullItemSharedInfoPointer) {}
454 ItemBase(ItemBaseBuildInfo x) : m_local_id(x.m_local_id), m_shared_info(x.m_shared_info) {}
455
456 public:
457
458 // TODO: A supprimer à terme
459 inline ItemBase(ItemInternal* x);
460
461 public:
462
464 Int32 localId() const { return m_local_id; }
466 inline ItemLocalId itemLocalId() const;
468 ItemUniqueId uniqueId() const
469 {
470#ifdef ARCANE_CHECK
471 if (m_local_id!=NULL_ITEM_LOCAL_ID)
472 arcaneCheckAt((Integer)m_local_id,m_shared_info->m_unique_ids.size());
473#endif
474 // Ne pas utiliser l'accesseur normal car ce tableau peut etre utilise pour la maille
475 // nulle et dans ce cas m_local_id vaut NULL_ITEM_LOCAL_ID (qui est negatif)
476 // ce qui provoque une exception pour debordement de tableau.
477 return ItemUniqueId(m_shared_info->m_unique_ids.data()[m_local_id]);
478 }
479
481 Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }
482
484 Int32 flags() const { return m_shared_info->_flagsV2(m_local_id); }
485
487 Integer nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }
489 Integer nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }
491 Integer nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }
493 Integer nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }
495 Int32 nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }
497 Int32 nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }
499 Integer nbParent() const { return m_shared_info->nbParent(); }
500
501 public:
502
504 Int16 typeId() const { return m_shared_info->_typeId(m_local_id); }
506 ItemTypeId itemTypeId() const { return ItemTypeId(typeId()); }
508 ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(typeId()); }
509
513 inline Int32 level() const
514 {
518 if (this->nbHParent() == 0)
519 return 0;
521 return (this->hParentBase(0).level() + 1);
522 }
523
526 inline bool isAncestor() const
527 {
528 if (this->isActive())
529 return false;
530 if (!this->hasHChildren())
531 return false;
532 if (this->hChildBase(0).isActive())
533 return true;
534 return this->hChildBase(0).isAncestor();
535 }
538 inline bool hasHChildren () const
539 {
540 if (this->nbHChildren() == 0) // TODO ? à vérifier !
541 return false;
542 else
543 return true;
544 }
545
549 inline bool isActive() const
550 {
551 if ( (flags() & II_Inactive) | (flags() & II_CoarsenInactive))
552 return false;
553 else
554 return true;
555 }
556
559 inline bool isSubactive() const
560 {
561 if (this->isActive())
562 return false;
563 if (!this->hasHChildren())
564 return true;
565 return this->hChildBase(0).isSubactive();
566 }
567
569 IItemFamily* family() const { return m_shared_info->m_item_family; }
571 eItemKind kind() const { return m_shared_info->m_item_kind; }
573 bool null() const { return m_local_id==NULL_ITEM_LOCAL_ID; }
575 bool isNull() const { return m_local_id==NULL_ITEM_LOCAL_ID; }
577 bool isOwn() const { return ItemFlags::isOwn(flags()); }
584 bool isShared() const { return ItemFlags::isShared(flags()); }
585
587 bool isSuppressed() const { return (flags() & II_Suppressed)!=0; }
589 bool isDetached() const { return (flags() & II_Detached)!=0; }
590
592 bool isBoundary() const { return ItemFlags::isBoundary(flags()); }
594 ItemBase boundaryCell() const { return (flags() & II_Boundary) ? cellBase(0) : ItemBase(); }
596 ItemBase backCell() const
597 {
598 if (flags() & II_HasBackCell)
599 return cellBase((flags() & II_BackCellIsFirst) ? 0 : 1);
600 return {};
601 }
603 Int32 backCellId() const
604 {
605 if (flags() & II_HasBackCell)
606 return cellId((flags() & II_BackCellIsFirst) ? 0 : 1);
607 return NULL_ITEM_LOCAL_ID;
608 }
610 ItemBase frontCell() const
611 {
612 if (flags() & II_HasFrontCell)
613 return cellBase((flags() & II_FrontCellIsFirst) ? 0 : 1);
614 return {};
615 }
617 Int32 frontCellId() const
618 {
619 if (flags() & II_HasFrontCell)
620 return cellId((flags() & II_FrontCellIsFirst) ? 0 : 1);
621 return NULL_ITEM_LOCAL_ID;
622 }
623 ItemBase masterFace() const
624 {
625 if (flags() & II_SlaveFace)
626 return faceBase(0);
627 return {};
628 }
630 inline bool isMasterFace() const { return flags() & II_MasterFace; }
631
633 inline bool isSlaveFace() const { return flags() & II_SlaveFace; }
634
635 Int32 parentId(Integer index) const { return m_shared_info->_parentLocalIdV2(m_local_id,index); }
636
638 Int32 nodeId(Integer index) const { return _connectivity()->_nodeLocalIdV2(m_local_id,index); }
639 Int32 edgeId(Integer index) const { return _connectivity()->_edgeLocalIdV2(m_local_id,index); }
640 Int32 faceId(Integer index) const { return _connectivity()->_faceLocalIdV2(m_local_id,index); }
641 Int32 cellId(Integer index) const { return _connectivity()->_cellLocalIdV2(m_local_id,index); }
642 Int32 hParentId(Int32 index) const { return _connectivity()->_hParentLocalIdV2(m_local_id,index); }
643 Int32 hChildId(Int32 index) const { return _connectivity()->_hChildLocalIdV2(m_local_id,index); }
645
657 ARCANE_DEPRECATED_REASON("Y2023: Use nodeList() instead.")
658 ItemInternalVectorView internalNodes() const { return _connectivity()->nodesV2(m_local_id); }
659 ARCANE_DEPRECATED_REASON("Y2023: Use edgeList() instead.")
660 ItemInternalVectorView internalEdges() const { return _connectivity()->edgesV2(m_local_id); }
661 ARCANE_DEPRECATED_REASON("Y2023: Use faceList() instead.")
662 ItemInternalVectorView internalFaces() const { return _connectivity()->facesV2(m_local_id); }
663 ARCANE_DEPRECATED_REASON("Y2023: Use cellList() instead.")
664 ItemInternalVectorView internalCells() const { return _connectivity()->cellsV2(m_local_id); }
666
678 impl::ItemIndexedListView<DynExtent> nodeList() const { return _connectivity()->nodeList(m_local_id); }
679 impl::ItemIndexedListView<DynExtent> edgeList() const { return _connectivity()->edgeList(m_local_id); }
680 impl::ItemIndexedListView<DynExtent> faceList() const { return _connectivity()->faceList(m_local_id); }
681 impl::ItemIndexedListView<DynExtent> cellList() const { return _connectivity()->cellList(m_local_id); }
682
683 impl::ItemIndexedListView<DynExtent> itemList(Node*) const { return nodeList(); }
684 impl::ItemIndexedListView<DynExtent> itemList(Edge*) const { return edgeList(); }
685 impl::ItemIndexedListView<DynExtent> itemList(Face*) const { return faceList(); }
686 impl::ItemIndexedListView<DynExtent> itemList(Cell*) const { return cellList(); }
688
689 ItemBase nodeBase(Int32 index) const { return _connectivity()->nodeBase(m_local_id,index); }
690 ItemBase edgeBase(Int32 index) const { return _connectivity()->edgeBase(m_local_id,index); }
691 ItemBase faceBase(Int32 index) const { return _connectivity()->faceBase(m_local_id,index); }
692 ItemBase cellBase(Int32 index) const { return _connectivity()->cellBase(m_local_id,index); }
693 ItemBase hParentBase(Int32 index) const { return _connectivity()->hParentBase(m_local_id, index, m_shared_info); }
694 ItemBase hChildBase(Int32 index) const { return _connectivity()->hChildBase(m_local_id, index, m_shared_info); }
695 inline ItemBase parentBase(Int32 index) const;
696
697 public:
698
704 Int32 whichChildAmI(Int32 local_id) const;
705
706 public:
707
708 ItemBase topHParentBase() const;
709
710 public:
711
713 inline MutableItemBase toMutable();
714
715 public:
716
717 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")
718 inline ItemInternal* itemInternal() const;
719
720 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")
721 ItemInternalVectorView _internalActiveCells(Int32Array& local_ids) const
722 {
723 return _internalActiveCells2(local_ids);
724 }
725
726 private:
727
734 Int32 m_local_id = NULL_ITEM_LOCAL_ID;
735
737 Int32 m_padding = 0;
738
740 ItemSharedInfo* m_shared_info = nullptr;
741
742 private:
743
744 ItemInternalConnectivityList* _connectivity() const
745 {
746 return m_shared_info->m_connectivity;
747 }
748 void _setFromInternal(ItemBase* rhs)
749 {
750 m_local_id = rhs->m_local_id;
751 m_shared_info = rhs->m_shared_info;
752 }
753 void _setFromInternal(const ItemBase& rhs)
754 {
755 m_local_id = rhs.m_local_id;
756 m_shared_info = rhs.m_shared_info;
757 }
758 ItemInternalVectorView _internalActiveCells2(Int32Array& local_ids) const;
759 inline ItemInternal* _itemInternal() const;
760};
761
762/*---------------------------------------------------------------------------*/
763/*---------------------------------------------------------------------------*/
769class ARCANE_CORE_EXPORT MutableItemBase
770: public ItemBase
771{
772 friend class ::Arcane::Item;
773 friend ItemBase;
774 // Pour _setFaceBackAndFrontCell()
775 friend Arcane::mesh::FaceFamily;
776
777 private:
778
779 MutableItemBase(Int32 local_id,ItemSharedInfo* shared_info)
780 : ItemBase(local_id, shared_info) {}
781
782 public:
783
784 MutableItemBase() = default;
785 MutableItemBase(ItemBaseBuildInfo x) : ItemBase(x) {}
786 explicit MutableItemBase(const ItemBase& x)
787 : ItemBase(x)
788 {}
789
790 public:
791
792 // TODO: A supprimer à terme
793 inline MutableItemBase(ItemInternal* x);
794
795 public:
796
797 void setUniqueId(Int64 uid)
798 {
799 _checkUniqueId(uid);
800 m_shared_info->m_unique_ids[m_local_id] = uid;
801 }
802
804
805 void unsetUniqueId();
806
817 void setOwner(Integer suid,Int32 current_sub_domain)
818 {
819 m_shared_info->_setOwnerV2(m_local_id,suid);
820 int f = flags();
821 if (suid==current_sub_domain)
822 f |= II_Own;
823 else
824 f &= ~II_Own;
825 setFlags(f);
826 }
827
829 void setFlags(Int32 f) { m_shared_info->_setFlagsV2(m_local_id,f); }
830
832 void addFlags(Int32 added_flags)
833 {
834 Int32 f = this->flags();
835 f |= added_flags;
836 this->setFlags(f);
837 }
838
840 void removeFlags(Int32 removed_flags)
841 {
842 Int32 f = this->flags();
843 f &= ~removed_flags;
844 this->setFlags(f);
845 }
846
848 void setDetached(bool v)
849 {
850 int f = flags();
851 if (v)
852 f |= II_Detached;
853 else
854 f &= ~II_Detached;
855 setFlags(f);
856 }
857
858 void reinitialize(Int64 uid,Int32 aowner,Int32 owner_rank)
859 {
860 setUniqueId(uid);
861 setFlags(0);
862 setOwner(aowner,owner_rank);
863 }
864
865 void setLocalId(Int32 local_id)
866 {
867 m_local_id = local_id;
868 }
869
871 void setParent(Int32 aindex,Int32 parent_local_id)
872 {
873 m_shared_info->_setParentV2(m_local_id,aindex,parent_local_id);
874 }
875
876 private:
877
878 void _setFaceBackAndFrontCells(Int32 back_cell_lid, Int32 front_cell_lid);
879
880 void _checkUniqueId(Int64 new_uid) const;
881
882 inline void _setFaceInfos(Int32 mod_flags);
883};
884
885/*---------------------------------------------------------------------------*/
886/*---------------------------------------------------------------------------*/
906class ARCANE_CORE_EXPORT ItemInternal
907: public impl::MutableItemBase
908{
909 // Pour accès à _setSharedInfo()
910 friend class mesh::DynamicMeshKindInfos;
911 friend class mesh::ItemFamily;
912
913 public:
914
916 static ItemInternal nullItemInternal;
917 static ItemInternal* nullItem() { return &nullItemInternal; }
918
919 public:
920
921 // Il faut utiliser la méthode correspondante de ItemBase
922
924 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::boundaryCell() instead.")
925 ItemInternal* boundaryCell() const { return (flags() & II_Boundary) ? _internalCell(0) : nullItem(); }
927 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::backCell() instead.")
928 ItemInternal* backCell() const
929 {
930 if (flags() & II_HasBackCell)
931 return _internalCell((flags() & II_BackCellIsFirst) ? 0 : 1);
932 return nullItem();
933 }
935 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::frontCell() instead.")
936 ItemInternal* frontCell() const
937 {
938 if (flags() & II_HasFrontCell)
939 return _internalCell((flags() & II_FrontCellIsFirst) ? 0 : 1);
940 return nullItem();
941 }
942 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::masterFace() instead.")
943 ItemInternal* masterFace() const
944 {
945 if (flags() & II_SlaveFace)
946 return _internalFace(0);
947 return nullItem();
948 }
949
950 public:
951
953 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
954 ItemSharedInfo* sharedInfo() const { return m_shared_info; }
955
956 public:
957
958 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
959 ItemInternalVectorView internalItems(Node*) const { return nodeList(); }
960 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
961 ItemInternalVectorView internalItems(Edge*) const { return edgeList(); }
962 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
963 ItemInternalVectorView internalItems(Face*) const { return faceList(); }
964 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
965 ItemInternalVectorView internalItems(Cell*) const { return cellList(); }
966
967 public:
968
969 ARCANE_DEPRECATED_REASON("Y2023: Use nodeBase() instead.")
970 ItemInternal* internalNode(Int32 index) const { return _connectivity()->_nodeV2(m_local_id,index); }
971 ARCANE_DEPRECATED_REASON("Y2023: Use edgeBase() instead.")
972 ItemInternal* internalEdge(Int32 index) const { return _connectivity()->_edgeV2(m_local_id,index); }
973 ARCANE_DEPRECATED_REASON("Y2023: Use faceBase() instead.")
974 ItemInternal* internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id,index); }
975 ARCANE_DEPRECATED_REASON("Y2023: Use cellBase() instead.")
976 ItemInternal* internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id,index); }
977 ARCANE_DEPRECATED_REASON("Y2023: Use hParentBase() instead.")
978 ItemInternal* internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id,index); }
979 ARCANE_DEPRECATED_REASON("Y2023: Use hChildBase() instead.")
980 ItemInternal* internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id,index); }
981 ARCANE_DEPRECATED_REASON("Y2023: Use parentBase() instead.")
982 ItemInternal* parent(Integer index) const { return m_shared_info->_parentV2(m_local_id,index); }
983
984 public:
985
986 const ItemInternal* topHParent() const;
987 ItemInternal* topHParent();
988
989 public:
990
991 ARCANE_DEPRECATED_REASON("Y2022: This method always returns 0")
992 Int32 dataIndex() { return 0; }
993
994 public:
995
1007 ARCANE_DEPRECATED_REASON("Y2022: Use parentId() or setParent() instead")
1008 Int32* parentPtr() { return m_shared_info->_parentPtr(m_local_id); }
1009
1015 Int32 whichChildAmI(const ItemInternal *iitem) const;
1016
1017 public:
1018
1020 ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")
1021 constexpr Integer neededMemory() const { return 0; }
1022
1024 ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")
1025 constexpr Integer minimumNeededMemory() const { return 0; }
1026
1027 public:
1028
1029 ARCANE_DEPRECATED_REASON("Y2023: Use nodeId() instead")
1030 Int32 nodeLocalId(Integer index) { return _connectivity()->_nodeLocalIdV2(m_local_id,index); }
1031 ARCANE_DEPRECATED_REASON("Y2023: Use edgeId() instead")
1032 Int32 edgeLocalId(Integer index) { return _connectivity()->_edgeLocalIdV2(m_local_id,index); }
1033 ARCANE_DEPRECATED_REASON("Y2023: Use faceId() instead")
1034 Int32 faceLocalId(Integer index) { return _connectivity()->_faceLocalIdV2(m_local_id,index); }
1035 ARCANE_DEPRECATED_REASON("Y2023: Use cellId() instead")
1036 Int32 cellLocalId(Integer index) { return _connectivity()->_cellLocalIdV2(m_local_id,index); }
1037
1038 public:
1039
1040 ARCANE_DEPRECATED_REASON("Y2022: This method always throws an exception.")
1041 void setDataIndex(Integer);
1042
1043 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
1044 void setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)
1045 {
1046 _setSharedInfo(shared_infos,type_id);
1047 }
1048
1049 public:
1050
1052 typedef ItemInternal* ItemInternalPtr;
1053
1055 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
1056 static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items)
1057 {
1058 return ((items) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());
1059 }
1060
1061 private:
1062
1063 void _setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)
1064 {
1065 m_shared_info = shared_infos;
1066 shared_infos->_setTypeId(m_local_id,type_id.typeId());
1067 }
1068
1069 ItemInternal* _internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id, index); }
1070 ItemInternal* _internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id, index); }
1071 ItemInternal* _internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id, index); }
1072 ItemInternal* _internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id, index); }
1073};
1074
1075/*---------------------------------------------------------------------------*/
1076/*---------------------------------------------------------------------------*/
1077
1078impl::ItemBase::
1079ItemBase(ItemInternal* x)
1080: m_local_id(x->m_local_id)
1081, m_shared_info(x->m_shared_info)
1082{}
1083
1084/*---------------------------------------------------------------------------*/
1085/*---------------------------------------------------------------------------*/
1086
1087impl::MutableItemBase::
1088MutableItemBase(ItemInternal* x)
1089: ItemBase(x)
1090{}
1091
1092/*---------------------------------------------------------------------------*/
1093/*---------------------------------------------------------------------------*/
1094
1095inline ItemLocalId::
1096ItemLocalId(ItemInternal* item)
1097: m_local_id(item->localId())
1098{
1099}
1100
1101/*---------------------------------------------------------------------------*/
1102/*---------------------------------------------------------------------------*/
1103
1104// TODO: ajouter vérification du bon type
1105template<typename ItemType> inline ItemLocalIdT<ItemType>::
1106ItemLocalIdT(ItemInternal* item)
1107: ItemLocalId(item->localId())
1108{
1109}
1110
1111/*---------------------------------------------------------------------------*/
1112/*---------------------------------------------------------------------------*/
1113
1114inline ItemInternal* impl::ItemBase::
1115itemInternal() const
1116{
1117 if (m_local_id!=NULL_ITEM_LOCAL_ID)
1118 return m_shared_info->m_items_internal[m_local_id];
1119 return ItemInternal::nullItem();
1120}
1121
1122/*---------------------------------------------------------------------------*/
1123/*---------------------------------------------------------------------------*/
1124
1125inline ItemInternal* impl::ItemBase::
1126_itemInternal() const
1127{
1128 if (m_local_id!=NULL_ITEM_LOCAL_ID)
1129 return m_shared_info->m_items_internal[m_local_id];
1130 return ItemInternal::nullItem();
1131}
1132
1133/*---------------------------------------------------------------------------*/
1134/*---------------------------------------------------------------------------*/
1135
1136inline impl::ItemBase impl::ItemBase::
1137parentBase(Int32 index) const
1138{
1139 return ItemBase(m_shared_info->_parentV2(m_local_id,index));
1140}
1141
1142/*---------------------------------------------------------------------------*/
1143/*---------------------------------------------------------------------------*/
1144
1150
1151/*---------------------------------------------------------------------------*/
1152/*---------------------------------------------------------------------------*/
1153
1154inline ItemLocalId impl::ItemBase::
1155itemLocalId() const
1156{
1157 return ItemLocalId(m_local_id);
1158}
1159
1160/*---------------------------------------------------------------------------*/
1161/*---------------------------------------------------------------------------*/
1170class ItemInternalCompatibility
1171{
1172 friend class SimdItemBase;
1173 friend class SimdItemDirectBase;
1174 friend class SimdItem;
1175 friend class SimdItemEnumeratorBase;
1176 friend class ItemVectorView;
1177 template<typename T> friend class ItemEnumeratorBaseT;
1178 friend class mesh::DynamicMeshKindInfos;
1179 friend class TotalviewAdapter;
1180 template<int Extent> friend class ItemConnectedListView;
1181
1182 private:
1183
1185 typedef ItemInternal* ItemInternalPtr;
1186 static ItemSharedInfo* _getSharedInfo(const ItemInternal* item)
1187 {
1188 return item->m_shared_info;
1189 }
1190 static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items,Int32 count)
1191 {
1192 return ((items && count>0) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());
1193 }
1194 static const ItemInternalPtr* _getItemInternalPtr(ItemSharedInfo* shared_info)
1195 {
1196 ARCANE_CHECK_PTR(shared_info);
1197 return shared_info->m_items_internal.data();
1198 }
1199};
1200
1201/*---------------------------------------------------------------------------*/
1202/*---------------------------------------------------------------------------*/
1203
1204} // End namespace Arcane
1205
1206/*---------------------------------------------------------------------------*/
1207/*---------------------------------------------------------------------------*/
1208
1209#endif
ItemTypes.h
Déclarations de types sur les entités.
Arcane::IItemFamily
Interface d'une famille d'entités.
Definition IItemFamily.h:111
Arcane::ItemBaseBuildInfo
Classe pour construire une instance de ItemBase.
Definition ItemInternal.h:70
Arcane::ItemBase
Classe de base pour les entités du maillage.
Definition ItemInternal.h:433
Arcane::ItemBase::nbEdge
Integer nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
Definition ItemInternal.h:489
Arcane::ItemBase::itemLocalId
ItemLocalId itemLocalId() const
Numéro local (au sous-domaine) de l'entité
Definition ItemInternal.h:1155
Arcane::ItemBase::isSuppressed
bool isSuppressed() const
Vrai si l'entité est supprimée.
Definition ItemInternal.h:587
Arcane::ItemBase::uniqueId
ItemUniqueId uniqueId() const
Numéro unique de l'entité
Definition ItemInternal.h:468
Arcane::ItemBase::backCellId
Int32 backCellId() const
Maille derrière l'entité (NULL_ITEM_LOCAL_ID si aucune)
Definition ItemInternal.h:603
Arcane::ItemBase::kind
eItemKind kind() const
Genre de l'entité
Definition ItemInternal.h:571
Arcane::ItemBase::nbCell
Integer nbCell() const
Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
Definition ItemInternal.h:493
Arcane::ItemBase::isMasterFace
bool isMasterFace() const
true s'il s'agit de la face maître d'une interface
Definition ItemInternal.h:630
Arcane::ItemBase::family
IItemFamily * family() const
Famille dont est issue l'entité
Definition ItemInternal.h:569
Arcane::ItemBase::m_local_id
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
Definition ItemInternal.h:734
Arcane::ItemBase::owner
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition ItemInternal.h:481
Arcane::ItemBase::isActive
bool isActive() const
Definition ItemInternal.h:549
Arcane::ItemBase::level
Int32 level() const
Definition ItemInternal.h:513
Arcane::ItemBase::toMutable
MutableItemBase toMutable()
Interface modifiable de cette entité
Definition ItemInternal.h:1146
Arcane::ItemBase::flags
Int32 flags() const
Flags de l'entité
Definition ItemInternal.h:484
Arcane::ItemBase::isShared
bool isShared() const
Vrai si l'entité est partagé d'autres sous-domaines.
Definition ItemInternal.h:584
Arcane::ItemBase::backCell
ItemBase backCell() const
Maille derrière l'entité (nullItem() si aucune)
Definition ItemInternal.h:596
Arcane::ItemBase::isDetached
bool isDetached() const
Vrai si l'entité est détachée.
Definition ItemInternal.h:589
Arcane::ItemBase::nbFace
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 ItemInternal.h:491
Arcane::ItemBase::isSubactive
bool isSubactive() const
Definition ItemInternal.h:559
Arcane::ItemBase::nodeList
impl::ItemIndexedListView< DynExtent > nodeList() const
Méthodes utilisant les nouvelles connectivités pour accéder aux informations de connectivité....
Definition ItemInternal.h:678
Arcane::ItemBase::typeInfo
ItemTypeInfo * typeInfo() const
Type de l'entité.
Definition ItemInternal.h:508
Arcane::ItemBase::typeId
Int16 typeId() const
Type de l'entité
Definition ItemInternal.h:504
Arcane::ItemBase::nbHParent
Int32 nbHParent() const
Nombre de parents pour l'AMR.
Definition ItemInternal.h:495
Arcane::ItemBase::hasHChildren
bool hasHChildren() const
Definition ItemInternal.h:538
Arcane::ItemBase::isOwn
bool isOwn() const
Vrai si l'entité appartient au sous-domaine.
Definition ItemInternal.h:577
Arcane::ItemBase::itemTypeId
ItemTypeId itemTypeId() const
Type de l'entité
Definition ItemInternal.h:506
Arcane::ItemBase::isAncestor
bool isAncestor() const
Definition ItemInternal.h:526
Arcane::ItemBase::nbHChildren
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition ItemInternal.h:497
Arcane::ItemBase::isNull
bool isNull() const
Vrai si l'entité est l'entité nulle.
Definition ItemInternal.h:575
Arcane::ItemBase::nbNode
Integer nbNode() const
Nombre de noeuds de l'entité
Definition ItemInternal.h:487
Arcane::ItemBase::boundaryCell
ItemBase boundaryCell() const
Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
Definition ItemInternal.h:594
Arcane::ItemBase::isBoundary
bool isBoundary() const
true si l'entité est sur la frontière
Definition ItemInternal.h:592
Arcane::ItemBase::m_shared_info
ItemSharedInfo * m_shared_info
Infos partagées entre toutes les entités ayant les mêmes caractéristiques.
Definition ItemInternal.h:740
Arcane::ItemBase::frontCellId
Int32 frontCellId() const
Maille devant l'entité (NULL_ITEM_LOCAL_ID si aucune)
Definition ItemInternal.h:617
Arcane::ItemBase::nbParent
Integer nbParent() const
Nombre de parent pour les sous-maillages.
Definition ItemInternal.h:499
Arcane::ItemBase::null
bool null() const
Vrai si l'entité est l'entité nulle.
Definition ItemInternal.h:573
Arcane::ItemBase::frontCell
ItemBase frontCell() const
Maille devant l'entité (nullItem() si aucune)
Definition ItemInternal.h:610
Arcane::ItemBase::localId
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Definition ItemInternal.h:464
Arcane::ItemBase::isSlaveFace
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Definition ItemInternal.h:633
Arcane::ItemConnectedListView
Vue sur une liste d'entités connectées à une autre entité.
Definition ItemConnectedListView.h:226
Arcane::ItemConnectivityContainerView
Vues sur les conteneurs contenant les connectivités. Cette classe permet de rendre opaque en dehors d...
Definition ItemConnectivityContainerView.h:44
Arcane::ItemEnumeratorBaseT
Classe de base des énumérateurs sur une liste d'entité.
Definition ItemEnumeratorBase.h:199
Arcane::ItemFlags
Flags pour les caractéristiques des entités.
Definition ItemFlags.h:31
Arcane::ItemInternalCompatibility
Méthodes pour conversions entre différentes classes de gestion des entités.
Definition ItemInternal.h:1171
Arcane::ItemInternalConnectivityList
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Definition ItemInternal.h:89
Arcane::ItemInternalConnectivityList::nbAccess
Int64 nbAccess() const
Nombre d'appel à itemLocalId()
Definition ItemInternal.h:212
Arcane::ItemInternalConnectivityList::_setConnectivityNbItem
void _setConnectivityNbItem(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau contenant le nombre d'entités connectées.
Definition ItemInternal.h:230
Arcane::ItemInternalConnectivityList::maxNbConnectedItem
Int32 maxNbConnectedItem(Int32 item_kind) const
Nombre maximum d'entités connectées.
Definition ItemInternal.h:264
Arcane::ItemInternalConnectivityList::itemLocalId
Int32 itemLocalId(Int32 item_kind, Int32 lid, Integer index) const
localId() de la index-ème entité de type item_kind connectés à l'entité de de localid() lid.
Definition ItemInternal.h:207
Arcane::ItemInternalConnectivityList::nbAccessAll
Int64 nbAccessAll() const
Nombre d'appel à itemLocalIds()
Definition ItemInternal.h:214
Arcane::ItemInternalConnectivityList::_setConnectivityList
void _setConnectivityList(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau contenant la liste des connectivités.
Definition ItemInternal.h:224
Arcane::ItemInternalConnectivityList::_setConnectivityIndex
void _setConnectivityIndex(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau d'index des connectivités.
Definition ItemInternal.h:219
Arcane::ItemInternalConnectivityList::_setMaxNbConnectedItem
void _setMaxNbConnectedItem(Int32 item_kind, Int32 v)
Positionne le nombre maximum d'entités connectées.
Definition ItemInternal.h:235
Arcane::ItemInternalVectorView
Vue interne sur un tableau d'entités.
Definition ItemInternalVectorView.h:124
Arcane::ItemInternal
Structure interne d'une entité de maillage.
Definition ItemInternal.h:908
Arcane::ItemInternal::ItemInternalPtr
ItemInternal * ItemInternalPtr
Definition ItemInternal.h:1052
Arcane::ItemInternal::ARCANE_DEPRECATED_REASON
ARCANE_DEPRECATED_REASON("Y2022: Use parentId() or setParent() instead") Int32 *parentPtr()
Pointeur sur la liste des parents.
Definition ItemInternal.h:1007
Arcane::ItemInternal::nullItemInternal
static ItemInternal nullItemInternal
Entité nulle.
Definition ItemInternal.h:916
Arcane::ItemLocalId
Index d'un Item dans une variable.
Definition ItemLocalId.h:40
Arcane::ItemSharedInfo
Structure interne partagée d'une entité de maillage.
Definition ItemSharedInfo.h:55
Arcane::ItemSharedInfo::m_items_internal
ConstArrayView< ItemInternal * > m_items_internal
ItemInternal des entités.
Definition ItemSharedInfo.h:280
Arcane::ItemTypeId
Type d'une entité (Item).
Definition ItemTypeId.h:32
Arcane::ItemTypeInfo
Infos sur un type d'entité du maillage.
Definition ItemTypeInfo.h:47
Arcane::ItemUniqueId
Identifiant unique d'une entité.
Definition ItemUniqueId.h:35
Arcane::ItemVectorView
Vue sur un vecteur d'entités.
Definition ItemVectorView.h:227
Arcane::Item
Classe de base d'un élément de maillage.
Definition Item.h:83
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::MeshItemInternalList
Tableaux d'indirection sur les entités d'un maillage.
Definition MeshItemInternalList.h:79
Arcane::MutableItemBase
Méthodes permettant de modifier ItemBase.
Definition ItemInternal.h:771
Arcane::MutableItemBase::setOwner
void setOwner(Integer suid, Int32 current_sub_domain)
Positionne le numéro du sous-domaine propriétaire de l'entité.
Definition ItemInternal.h:817
Arcane::MutableItemBase::setDetached
void setDetached(bool v)
Positionne l'état détachée de l'entité
Definition ItemInternal.h:848
Arcane::MutableItemBase::setFlags
void setFlags(Int32 f)
Positionne les flags de l'entité
Definition ItemInternal.h:829
Arcane::MutableItemBase::setParent
void setParent(Int32 aindex, Int32 parent_local_id)
Positionne le i-ème parent (actuellement aindex doit valoir 0)
Definition ItemInternal.h:871
Arcane::MutableItemBase::addFlags
void addFlags(Int32 added_flags)
Ajoute les flags \added_flags à ceux de l'entité
Definition ItemInternal.h:832
Arcane::MutableItemBase::removeFlags
void removeFlags(Int32 removed_flags)
Supprime les flags \added_flags de ceux de l'entité
Definition ItemInternal.h:840
Arcane::Node
Noeud d'un maillage.
Definition Dom.h:204
Arcane::SimdItemBase
Classe gérant un vecteur SIMD d'entité.
Definition SimdItem.h:67
Arcane::SimdItemEnumeratorBase
Classe de base des énumérateurs sur les entités vectortielles (SimdItem).
Definition SimdItem.h:376
Arcane::SimdItem
Gère un vecteur d'entité Item.
Definition SimdItem.h:206
Arcane::impl::ItemIndexedListView
Vue interne sur un tableau d'entités.
Definition ItemIndexedListView.h:44
Arcane::impl::ItemLocalIdListContainerView
Vue sur le conteneur d'une liste de ItemLocalId.
Definition ItemLocalIdListContainerView.h:39
Arcane::impl::MeshItemSharedInfoList
Liste des ItemSharedInfo associés à un maillage.
Definition MeshItemInternalList.h:42
Arcane::mesh::DynamicMeshKindInfos
Infos de maillage pour un genre donné d'entité.
Definition DynamicMeshKindInfos.h:53
Arcane::mesh::FaceFamily
Famille de faces.
Definition FaceFamily.h:53
Arcane::mesh::IncrementalItemConnectivityBase
Classe de base pour les connectivités incrémentales item->item[].
Definition IncrementalItemConnectivity.h:100
Arcane::mesh::ItemFamily
Famille d'entités.
Definition ItemFamily.h:76
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::NodeLocalIdView
ItemLocalIdListViewT< Node > NodeLocalIdView
Vue sur les localId() d'une liste de noeuds.
Definition ItemTypes.h:407
Arcane::EdgeLocalIdView
ItemLocalIdListViewT< Edge > EdgeLocalIdView
Vue sur les localId() d'une liste d'arêtes.
Definition ItemTypes.h:417
Arcane::FaceLocalIdView
ItemLocalIdListViewT< Face > FaceLocalIdView
Vue sur les localId() d'une liste de faces.
Definition ItemTypes.h:427
Arcane::CellLocalIdView
ItemLocalIdListViewT< Cell > CellLocalIdView
Vue sur les localId() d'une liste de mailles.
Definition ItemTypes.h:437
Arcane::Materials
Active toujours les traces dans les parties Arcane concernant les matériaux.
Definition ItemCompatibility.h:27
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:153
Arcane::ItemInternalConnectivityList::Container
Conteneur des vues pour les informations de connectivité d'une famille.
Definition ItemInternal.h:359
Arcane::ItemInternalConnectivityList::Int32View
Vue spécifique pour gérer les entités nulles.
Definition ItemInternal.h:115