Arcane  v3.16.2.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ItemInternal.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/* ItemInternal.h (C) 2000-2025 */
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
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{
58}
59namespace Arcane
60{
62
63/*---------------------------------------------------------------------------*/
64/*---------------------------------------------------------------------------*/
65/*!
66 * \internal
67 * \brief Classe pour construire une instance de ItemBase
68 */
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/*---------------------------------------------------------------------------*/
82/*!
83 * \internal
84 * \brief Informations de connectivité, pour une famille d'entité,
85 * permettant la transition entre les anciennes et nouvelles implémentations
86 * des connectivités.
87 */
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
107 /*!
108 * \brief Vue spécifique pour gérer les entités nulles.
109 *
110 * Pour l'entité nulle, l'index vaut NULL_ITEM_LOCAL_ID (soit (-1)) et il faut
111 * pouvoir accéder à `m_data` avec cet indice ce qui n'est pas possible
112 * avec le ArrayView classique en mode check.
113 */
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
203 /*!
204 * \brief localId() de la \a index-ème entité de type \a item_kind
205 * connectés à l'entité de de localid() \a lid.
206 */
207 Int32 itemLocalId(Int32 item_kind,Int32 lid,Integer index) const
208 {
209 return m_container[item_kind].itemLocalId(lid,index);
210 }
211 //! Nombre d'appel à itemLocalId()
212 Int64 nbAccess() const { return 0; }
213 //! Nombre d'appel à itemLocalIds()
214 Int64 nbAccessAll() const { return 0; }
215
216 private:
217
218 //! Positionne le tableau d'index des connectivités
219 void _setConnectivityIndex(Int32 item_kind,ConstArrayView<Int32> v)
220 {
221 m_container[item_kind].m_indexes = v;
222 }
223 //! Positionne le tableau contenant la liste des connectivités
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 }
229 //! Positionne le tableau contenant le nombre d'entités connectées.
230 void _setConnectivityNbItem(Int32 item_kind,ConstArrayView<Int32> v)
231 {
232 m_container[item_kind].m_nb_item = v;
233 }
234 //! Positionne le nombre maximum d'entités connectées.
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
242 //! Tableau d'index des connectivités pour les entités de genre \a item_kind
243 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
245 {
246 return m_container[item_kind].m_indexes;
247 }
248 //! Tableau contenant la liste des connectivités pour les entités de genre \a item_kind
249 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
251 {
252 return m_container[item_kind].m_list;
253 }
254 //! Tableau contenant le nombre d'entités connectées pour les entités de genre \a item_kind
255 ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")
257 {
258 return m_container[item_kind].m_nb_item;
259 }
260
261 public:
262
263 //! Nombre maximum d'entités connectées.
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
357 //! Conteneur des vues pour les informations de connectivité d'une famille
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/*---------------------------------------------------------------------------*/
415/*!
416 * \brief Classe de base pour les entités du maillage.
417 *
418 * Cette classe est interne à %Arcane.
419 *
420 * Cette classe est normalement interne à Arcane et il est préférable d'utiliser
421 * les versions spécialisés telles que Item, Node, Face, Edge, Cell, Particle
422 * ou DoF.
423 *
424 * Les instances de cette classe sont des objets temporaires qui ne doivent
425 * pas être conservés entre deux modifications topologiques du maillage s'il y
426 * a des compressions (IItemFamily::compactItems()) lors de ces modifications.
427 *
428 * L'ensemble des méthodes de cette classe sont en lecture seule et ne
429 * permettent pas de modifier une entité.
430 */
431class ARCANE_CORE_EXPORT ItemBase
432: public ItemFlags
433{
434 friend class ::Arcane::ItemInternal;
435 friend class ::Arcane::Item;
436 friend class ::Arcane::ItemInternalCompatibility;
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
463 //! Numéro local (au sous-domaine) de l'entité
464 Int32 localId() const { return m_local_id; }
465 //! Numéro local (au sous-domaine) de l'entité
466 inline ItemLocalId itemLocalId() const;
467 //! Numéro unique de l'entité
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
480 //! Numéro du sous-domaine propriétaire de l'entité
481 Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }
482
483 //! Flags de l'entité
484 Int32 flags() const { return m_shared_info->_flagsV2(m_local_id); }
485
486 //! Nombre de noeuds de l'entité
487 Integer nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }
488 //! Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
489 Integer nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }
490 //! Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
491 Integer nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }
492 //! Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
493 Integer nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }
494 //! Nombre de parents pour l'AMR
495 Int32 nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }
496 //! Nombre d'enfants pour l'AMR
497 Int32 nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }
498 //! Nombre de parent pour les sous-maillages
499 Integer nbParent() const { return m_shared_info->nbParent(); }
500
501 public:
502
503 //! Type de l'entité
504 Int16 typeId() const { return m_shared_info->_typeId(m_local_id); }
505 //! Type de l'entité
506 ItemTypeId itemTypeId() const { return ItemTypeId(typeId()); }
507 //! Type de l'entité.
508 ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(typeId()); }
509
510 //! @returns le niveau de raffinement de l'item courant. Si l'item
511 //! parent est \p NULL donc par convention il est au niveau 0,
512 //! sinon il est simplement au niveau que celui de son parent.
513 inline Int32 level() const
514 {
515 //! si je n'ai pas de parent donc j'ai été crée
516 //! directement à partir d'un fichier ou par l'utilisateur,
517 //! donc je suis un item de niveau 0
518 if (this->nbHParent() == 0)
519 return 0;
520 //! sinon je suis au niveau supérieur que celui de mon parent
521 return (this->hParentBase(0).level() + 1);
522 }
523
524 //! @returns \p true si l'item est un ancetre (i.e. a un
525 //! enfant actif ou un enfant ancetre), \p false sinon. Renvoie toujours \p false si l'AMR est désactivé.
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 }
536 //! @returns \p true si l'item a des enfants (actifs ou non),
537 //! \p false sinon. Renvoie toujours \p false si l'AMR est désactivé.
538 inline bool hasHChildren () const
539 {
540 if (this->nbHChildren() == 0) // TODO ? à vérifier !
541 return false;
542 else
543 return true;
544 }
545
546 //! @returns \p true si l'item est actif (i.e. n'a pas de
547 //! descendants actifs), \p false sinon. Notez qu'il suffit de vérifier
548 //! le premier enfant seulement. Renvoie toujours \p true si l'AMR est désactivé.
549 inline bool isActive() const
550 {
551 if ( (flags() & II_Inactive) | (flags() & II_CoarsenInactive))
552 return false;
553 else
554 return true;
555 }
556
557 //! @returns \p true si l'item est subactif (i.e. pas actif et n'a pas de
558 //! descendants), \p false sinon.Renvoie toujours \p false si l'AMR est désactivé.
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
568 //! Famille dont est issue l'entité
569 IItemFamily* family() const { return m_shared_info->m_item_family; }
570 //! Genre de l'entité
571 eItemKind kind() const { return m_shared_info->m_item_kind; }
572 //! Vrai si l'entité est l'entité nulle
573 bool null() const { return m_local_id==NULL_ITEM_LOCAL_ID; }
574 //! Vrai si l'entité est l'entité nulle
575 bool isNull() const { return m_local_id==NULL_ITEM_LOCAL_ID; }
576 //! Vrai si l'entité appartient au sous-domaine
577 bool isOwn() const { return ItemFlags::isOwn(flags()); }
578 /*!
579 * \brief Vrai si l'entité est partagé d'autres sous-domaines.
580 *
581 * Cette méthode n'est pertinente que si les informations de connectivités
582 * ont été calculées.
583 */
584 bool isShared() const { return ItemFlags::isShared(flags()); }
585
586 //! Vrai si l'entité est supprimée
587 bool isSuppressed() const { return (flags() & II_Suppressed)!=0; }
588 //! Vrai si l'entité est détachée
589 bool isDetached() const { return (flags() & II_Detached)!=0; }
590
591 //! \a true si l'entité est sur la frontière
592 bool isBoundary() const { return ItemFlags::isBoundary(flags()); }
593 //! Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
594 ItemBase boundaryCell() const { return (flags() & II_Boundary) ? cellBase(0) : ItemBase(); }
595 //! Maille derrière l'entité (nullItem() si aucune)
596 ItemBase backCell() const
597 {
598 if (flags() & II_HasBackCell)
599 return cellBase((flags() & II_BackCellIsFirst) ? 0 : 1);
600 return {};
601 }
602 //! Maille derrière l'entité (NULL_ITEM_LOCAL_ID si aucune)
604 {
605 if (flags() & II_HasBackCell)
606 return cellId((flags() & II_BackCellIsFirst) ? 0 : 1);
607 return NULL_ITEM_LOCAL_ID;
608 }
609 //! Maille devant l'entité (nullItem() si aucune)
610 ItemBase frontCell() const
611 {
612 if (flags() & II_HasFrontCell)
613 return cellBase((flags() & II_FrontCellIsFirst) ? 0 : 1);
614 return {};
615 }
616 //! Maille devant l'entité (NULL_ITEM_LOCAL_ID si aucune)
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 }
629 //! \a true s'il s'agit de la face maître d'une interface
630 inline bool isMasterFace() const { return flags() & II_MasterFace; }
631
632 //! \a true s'il s'agit d'une face esclave d'une interface
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
637 //@{
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); }
644 //@}
645
646 /*!
647 * \brief Méthodes utilisant les nouvelles connectivités pour accéder
648 * aux informations de connectivité. A ne pas utiliser en dehors de Arcane.
649 *
650 * \warning Ces méthodes ne doivent être appelées que sur les entités
651 * qui possèdent la connectivité associée ET qui sont au nouveau format.
652 * Par exemple, cela ne fonctionne pas sur Cell->Cell car il n'y a pas de
653 * connectivité maille/maille. En cas de mauvaise utilisation, cela
654 * se traduit par un débordement de tableau.
655 */
656 //@{
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); }
665 //@}
666
667 /*!
668 * \brief Méthodes utilisant les nouvelles connectivités pour accéder
669 * aux informations de connectivité. A ne pas utiliser en dehors de Arcane.
670 *
671 * \warning Ces méthodes ne doivent être appelées que sur les entités
672 * qui possèdent la connectivité associée.
673 * Par exemple, cela ne fonctionne pas sur Cell->Cell car il n'y a pas de
674 * connectivité maille/maille. En cas de mauvaise utilisation, cela
675 * se traduit par un débordement de tableau.
676 */
677 //@{
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(); }
687 //@}
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 //! Retourne si les flags \a flags sont positionnées pour l'entité
698 bool hasFlags(Int32 flags) const { return (this->flags() & flags); }
699
700 public:
701
702 /*!
703 * @returns le rang de l'enfant \p (iitem).
704 * exemple: si rank = m_internal->whichChildAmI(iitem); donc
705 * m_internal->hChild(rank) serait iitem;
706 */
707 Int32 whichChildAmI(Int32 local_id) const;
708
709 public:
710
711 ItemBase topHParentBase() const;
712
713 public:
714
715 //! Interface modifiable de cette entité
716 inline MutableItemBase toMutable();
717
718 public:
719
720 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")
721 inline ItemInternal* itemInternal() const;
722
723 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")
724 ItemInternalVectorView _internalActiveCells(Int32Array& local_ids) const
725 {
726 return _internalActiveCells2(local_ids);
727 }
728
729 private:
730
731 Int32 _nbLinearNode() const;
732
733 private:
734
735 /*!
736 * \brief Numéro local (au sous-domaine) de l'entité.
737 *
738 * Pour des raisons de performance, le numéro local doit être
739 * le premier champs de la classe.
740 */
741 Int32 m_local_id = NULL_ITEM_LOCAL_ID;
742
743 //! Champ servant uniquement à gérer explicitement l'alignement
744 Int32 m_padding = 0;
745
746 //! Infos partagées entre toutes les entités ayant les mêmes caractéristiques
747 ItemSharedInfo* m_shared_info = nullptr;
748
749 private:
750
751 ItemInternalConnectivityList* _connectivity() const
752 {
753 return m_shared_info->m_connectivity;
754 }
755 void _setFromInternal(ItemBase* rhs)
756 {
757 m_local_id = rhs->m_local_id;
758 m_shared_info = rhs->m_shared_info;
759 }
760 void _setFromInternal(const ItemBase& rhs)
761 {
762 m_local_id = rhs.m_local_id;
763 m_shared_info = rhs.m_shared_info;
764 }
765 ItemInternalVectorView _internalActiveCells2(Int32Array& local_ids) const;
766 inline ItemInternal* _itemInternal() const;
767};
768
769/*---------------------------------------------------------------------------*/
770/*---------------------------------------------------------------------------*/
771/*!
772 * \brief Méthodes permettant de modifier ItemBase.
773 *
774 * Ces méthodes sont internes à Arcane.
775 */
776class ARCANE_CORE_EXPORT MutableItemBase
777: public ItemBase
778{
779 friend class ::Arcane::Item;
780 friend ItemBase;
781 // Pour _setFaceBackAndFrontCell()
782 friend Arcane::mesh::FaceFamily;
783
784 private:
785
786 MutableItemBase(Int32 local_id,ItemSharedInfo* shared_info)
787 : ItemBase(local_id, shared_info) {}
788
789 public:
790
791 MutableItemBase() = default;
792 MutableItemBase(ItemBaseBuildInfo x) : ItemBase(x) {}
793 explicit MutableItemBase(const ItemBase& x)
794 : ItemBase(x)
795 {}
796
797 public:
798
799 // TODO: A supprimer à terme
800 inline MutableItemBase(ItemInternal* x);
801
802 public:
803
804 void setUniqueId(Int64 uid)
805 {
806 _checkUniqueId(uid);
807 m_shared_info->m_unique_ids[m_local_id] = uid;
808 }
809
810 //! Annule l'uniqueId a la valeur NULL_ITEM_UNIQUE_ID
811 /*! Controle que la valeur à annuler est valid en mode ARCANE_CHECK */
812 void unsetUniqueId();
813
814 /*!
815 * \brief Positionne le numéro du sous-domaine propriétaire de l'entité.
816
817 \a current_sub_domain est le numéro du sous-domaine appelant cette opération.
818
819 Après appel à cette fonction, il faut mettre à jour le maillage auquel cette entité
820 appartient en appelant la méthode IMesh::notifyOwnItemsChanged(). Il n'est pas
821 nécessaire de faire appel à cette méthode pour chaque appel de setOwn. Un seul
822 appel après l'ensemble des modification est nécessaire.
823 */
824 void setOwner(Integer suid,Int32 current_sub_domain)
825 {
826 m_shared_info->_setOwnerV2(m_local_id,suid);
827 int f = flags();
828 if (suid==current_sub_domain)
829 f |= II_Own;
830 else
831 f &= ~II_Own;
832 setFlags(f);
833 }
834
835 //! Positionne les flags de l'entité
836 void setFlags(Int32 f) { m_shared_info->_setFlagsV2(m_local_id,f); }
837
838 //! Ajoute les flags \a added_flags à ceux de l'entité
839 void addFlags(Int32 added_flags)
840 {
841 Int32 f = this->flags();
842 f |= added_flags;
843 this->setFlags(f);
844 }
845
846 //! Supprime les flags \a removed_flags de ceux de l'entité
847 void removeFlags(Int32 removed_flags)
848 {
849 Int32 f = this->flags();
850 f &= ~removed_flags;
851 this->setFlags(f);
852 }
853
854 //! Positionne l'état détachée de l'entité
855 void setDetached(bool v)
856 {
857 int f = flags();
858 if (v)
859 f |= II_Detached;
860 else
861 f &= ~II_Detached;
862 setFlags(f);
863 }
864
865 void reinitialize(Int64 uid,Int32 aowner,Int32 owner_rank)
866 {
867 setUniqueId(uid);
868 setFlags(0);
869 setOwner(aowner,owner_rank);
870 }
871
872 void setLocalId(Int32 local_id)
873 {
874 m_local_id = local_id;
875 }
876
877 //! Positionne le \a i-ème parent (actuellement aindex doit valoir 0)
878 void setParent(Int32 aindex,Int32 parent_local_id)
879 {
880 m_shared_info->_setParentV2(m_local_id,aindex,parent_local_id);
881 }
882
883 private:
884
885 void _setFaceBackAndFrontCells(Int32 back_cell_lid, Int32 front_cell_lid);
886
887 void _checkUniqueId(Int64 new_uid) const;
888
889 inline void _setFaceInfos(Int32 mod_flags);
890};
891
892/*---------------------------------------------------------------------------*/
893/*---------------------------------------------------------------------------*/
894/*!
895 * \internal
896 * \brief Structure interne d'une entité de maillage.
897
898 Cette instance contient la structure interne d'une entité de maillage.
899 Elle ne doit être manipulée que par ceux qui savent ce qu'il font...
900
901 Pour utiliser une entité, il faut utiliser la classe Item ou l'une
902 de ces classes dérivées.
903
904 En règle général, le maillage (IMesh) auquel l'entité appartient maintient
905 différentes structures permettant de manipuler le maillage. Ces structures
906 sont souvent recalculés dynamiquement lorsque cela est nécessaire (lazy
907 evaluation). C'est le cas par exemple des groupes d'entités propres
908 au sous-domaine ou de la table de conversion des numéros globaux en
909 numéros locaux. C'est pourquoi il est primordial lorqu'on effectue
910 une série de modifications d'instances de cette classe de notifier
911 le maillage des changements effectués.
912 */
913class ARCANE_CORE_EXPORT ItemInternal
914: public impl::MutableItemBase
915{
916 // Pour accès à _setSharedInfo()
917 friend class mesh::DynamicMeshKindInfos;
918 friend class mesh::ItemFamily;
919
920 public:
921
922 //! Entité nulle
924 static ItemInternal* nullItem() { return &nullItemInternal; }
925
926 public:
927
928 // Il faut utiliser la méthode correspondante de ItemBase
929
930 //! Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
931 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::boundaryCell() instead.")
932 ItemInternal* boundaryCell() const { return (flags() & II_Boundary) ? _internalCell(0) : nullItem(); }
933 //! Maille derrière l'entité (nullItem() si aucune)
934 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::backCell() instead.")
936 {
937 if (flags() & II_HasBackCell)
938 return _internalCell((flags() & II_BackCellIsFirst) ? 0 : 1);
939 return nullItem();
940 }
941 //! Maille devant l'entité (nullItem() si aucune)
942 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::frontCell() instead.")
944 {
945 if (flags() & II_HasFrontCell)
946 return _internalCell((flags() & II_FrontCellIsFirst) ? 0 : 1);
947 return nullItem();
948 }
949 ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::masterFace() instead.")
950 ItemInternal* masterFace() const
951 {
952 if (flags() & II_SlaveFace)
953 return _internalFace(0);
954 return nullItem();
955 }
956
957 public:
958
959 //! Infos partagées de l'entité.
960 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
961 ItemSharedInfo* sharedInfo() const { return m_shared_info; }
962
963 public:
964
965 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
966 ItemInternalVectorView internalItems(Node*) const { return nodeList(); }
967 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
968 ItemInternalVectorView internalItems(Edge*) const { return edgeList(); }
969 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
970 ItemInternalVectorView internalItems(Face*) const { return faceList(); }
971 ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")
972 ItemInternalVectorView internalItems(Cell*) const { return cellList(); }
973
974 public:
975
976 ARCANE_DEPRECATED_REASON("Y2023: Use nodeBase() instead.")
977 ItemInternal* internalNode(Int32 index) const { return _connectivity()->_nodeV2(m_local_id,index); }
978 ARCANE_DEPRECATED_REASON("Y2023: Use edgeBase() instead.")
979 ItemInternal* internalEdge(Int32 index) const { return _connectivity()->_edgeV2(m_local_id,index); }
980 ARCANE_DEPRECATED_REASON("Y2023: Use faceBase() instead.")
981 ItemInternal* internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id,index); }
982 ARCANE_DEPRECATED_REASON("Y2023: Use cellBase() instead.")
983 ItemInternal* internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id,index); }
984 ARCANE_DEPRECATED_REASON("Y2023: Use hParentBase() instead.")
985 ItemInternal* internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id,index); }
986 ARCANE_DEPRECATED_REASON("Y2023: Use hChildBase() instead.")
987 ItemInternal* internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id,index); }
988 ARCANE_DEPRECATED_REASON("Y2023: Use parentBase() instead.")
989 ItemInternal* parent(Integer index) const { return m_shared_info->_parentV2(m_local_id,index); }
990
991 public:
992
993 const ItemInternal* topHParent() const;
994 ItemInternal* topHParent();
995
996 public:
997
998 ARCANE_DEPRECATED_REASON("Y2022: This method always returns 0")
999 Int32 dataIndex() { return 0; }
1000
1001 public:
1002
1003 /*!
1004 * \brief Pointeur sur la liste des parents.
1005 *
1006 * Comme actuellement on ne supporte qu'un seul niveau il est uniquement autorisé
1007 * de faire parentPtr()[0]. Cela ne permet aucune vérification et il est
1008 * donc préférable d'utiliser parentId() ou setParent() à la place.
1009 *
1010 * Au mois de juillet 2022 cette méthode n'est plus utilisée dans Arcane donc si
1011 * aucun code ne l'utilise (ce qui devrait être le cas car il s'agit d'une méthode
1012 * interne) on pourra la supprimer rapidement.
1013 */
1014 ARCANE_DEPRECATED_REASON("Y2022: Use parentId() or setParent() instead")
1015 Int32* parentPtr() { return m_shared_info->_parentPtr(m_local_id); }
1016
1017 /*!
1018 * @returns le rang de l'enfant \p (iitem).
1019 * exemple: si rank = m_internal->whichChildAmI(iitem); donc
1020 * m_internal->hChild(rank) serait iitem;
1021 */
1022 Int32 whichChildAmI(const ItemInternal *iitem) const;
1023
1024 public:
1025
1026 //! Mémoire nécessaire pour stocker les infos de l'entité
1027 ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")
1028 constexpr Integer neededMemory() const { return 0; }
1029
1030 //! Mémoire minimale nécessaire pour stocker les infos de l'entité (sans tampon)
1031 ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")
1032 constexpr Integer minimumNeededMemory() const { return 0; }
1033
1034 public:
1035
1036 ARCANE_DEPRECATED_REASON("Y2023: Use nodeId() instead")
1037 Int32 nodeLocalId(Integer index) { return _connectivity()->_nodeLocalIdV2(m_local_id,index); }
1038 ARCANE_DEPRECATED_REASON("Y2023: Use edgeId() instead")
1039 Int32 edgeLocalId(Integer index) { return _connectivity()->_edgeLocalIdV2(m_local_id,index); }
1040 ARCANE_DEPRECATED_REASON("Y2023: Use faceId() instead")
1041 Int32 faceLocalId(Integer index) { return _connectivity()->_faceLocalIdV2(m_local_id,index); }
1042 ARCANE_DEPRECATED_REASON("Y2023: Use cellId() instead")
1043 Int32 cellLocalId(Integer index) { return _connectivity()->_cellLocalIdV2(m_local_id,index); }
1044
1045 public:
1046
1047 ARCANE_DEPRECATED_REASON("Y2022: This method always throws an exception.")
1048 void setDataIndex(Integer);
1049
1050 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
1051 void setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)
1052 {
1053 _setSharedInfo(shared_infos,type_id);
1054 }
1055
1056 public:
1057
1058 //! \internal
1059 typedef ItemInternal* ItemInternalPtr;
1060
1061 //! \internal
1062 ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")
1063 static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items)
1064 {
1065 return ((items) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());
1066 }
1067
1068 private:
1069
1070 void _setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)
1071 {
1072 m_shared_info = shared_infos;
1073 shared_infos->_setTypeId(m_local_id,type_id.typeId());
1074 }
1075
1076 ItemInternal* _internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id, index); }
1077 ItemInternal* _internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id, index); }
1078 ItemInternal* _internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id, index); }
1079 ItemInternal* _internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id, index); }
1080};
1081
1082/*---------------------------------------------------------------------------*/
1083/*---------------------------------------------------------------------------*/
1084
1085ItemBase::
1086ItemBase(ItemInternal* x)
1087: m_local_id(x->m_local_id)
1088, m_shared_info(x->m_shared_info)
1089{}
1090
1091/*---------------------------------------------------------------------------*/
1092/*---------------------------------------------------------------------------*/
1093
1094MutableItemBase::
1095MutableItemBase(ItemInternal* x)
1096: ItemBase(x)
1097{}
1098
1099/*---------------------------------------------------------------------------*/
1100/*---------------------------------------------------------------------------*/
1101
1102inline ItemLocalId::
1103ItemLocalId(ItemInternal* item)
1104: m_local_id(item->localId())
1105{
1106}
1107
1108/*---------------------------------------------------------------------------*/
1109/*---------------------------------------------------------------------------*/
1110
1111// TODO: ajouter vérification du bon type
1112template<typename ItemType> inline ItemLocalIdT<ItemType>::
1114: ItemLocalId(item->localId())
1115{
1116}
1117
1118/*---------------------------------------------------------------------------*/
1119/*---------------------------------------------------------------------------*/
1120
1121inline ItemInternal* impl::ItemBase::
1122itemInternal() const
1123{
1124 if (m_local_id!=NULL_ITEM_LOCAL_ID)
1125 return m_shared_info->m_items_internal[m_local_id];
1126 return ItemInternal::nullItem();
1127}
1128
1129/*---------------------------------------------------------------------------*/
1130/*---------------------------------------------------------------------------*/
1131
1132inline ItemInternal* impl::ItemBase::
1133_itemInternal() const
1134{
1135 if (m_local_id!=NULL_ITEM_LOCAL_ID)
1136 return m_shared_info->m_items_internal[m_local_id];
1137 return ItemInternal::nullItem();
1138}
1139
1140/*---------------------------------------------------------------------------*/
1141/*---------------------------------------------------------------------------*/
1142
1143inline impl::ItemBase impl::ItemBase::
1144parentBase(Int32 index) const
1145{
1146 return ItemBase(m_shared_info->_parentV2(m_local_id,index));
1147}
1148
1149/*---------------------------------------------------------------------------*/
1150/*---------------------------------------------------------------------------*/
1151
1152inline impl::MutableItemBase impl::ItemBase::
1153toMutable()
1154{
1155 return MutableItemBase(m_local_id,m_shared_info);
1156}
1157
1158/*---------------------------------------------------------------------------*/
1159/*---------------------------------------------------------------------------*/
1160
1162itemLocalId() const
1163{
1164 return ItemLocalId(m_local_id);
1165}
1166
1167/*---------------------------------------------------------------------------*/
1168/*---------------------------------------------------------------------------*/
1169/*!
1170 * \internal
1171 * \brief Méthodes pour conversions entre différentes classes de gestion
1172 * des entités
1173 *
1174 * Cette classe est temporaire et interne à Arcane. Seules les classes 'friend'
1175 * peuvent l'utiliser.
1176 */
1178{
1179 friend class SimdItemBase;
1180 friend class SimdItemDirectBase;
1181 friend class SimdItem;
1182 friend class SimdItemEnumeratorBase;
1183 friend class ItemVectorView;
1184 template<typename T> friend class ItemEnumeratorBaseT;
1185 friend class mesh::DynamicMeshKindInfos;
1186 friend class TotalviewAdapter;
1187 template<int Extent> friend class ItemConnectedListView;
1188
1189 private:
1190
1191 //! \internal
1192 typedef ItemInternal* ItemInternalPtr;
1193 static ItemSharedInfo* _getSharedInfo(const ItemInternal* item)
1194 {
1195 return item->m_shared_info;
1196 }
1197 static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items,Int32 count)
1198 {
1199 return ((items && count>0) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());
1200 }
1201 static const ItemInternalPtr* _getItemInternalPtr(ItemSharedInfo* shared_info)
1202 {
1203 ARCANE_CHECK_PTR(shared_info);
1204 return shared_info->m_items_internal.data();
1205 }
1206};
1207
1208/*---------------------------------------------------------------------------*/
1209/*---------------------------------------------------------------------------*/
1210
1211} // End namespace Arcane
1212
1213/*---------------------------------------------------------------------------*/
1214/*---------------------------------------------------------------------------*/
1215
1216#endif
Déclarations de types sur les entités.
Vue constante d'un tableau de type T.
constexpr const_pointer data() const noexcept
Pointeur sur la mémoire allouée.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Classe de base pour les entités du maillage.
Integer nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
ItemLocalId itemLocalId() const
Numéro local (au sous-domaine) de l'entité
bool isSuppressed() const
Vrai si l'entité est supprimée.
ItemUniqueId uniqueId() const
Numéro unique de l'entité
Int32 backCellId() const
Maille derrière l'entité (NULL_ITEM_LOCAL_ID si aucune)
eItemKind kind() const
Genre de l'entité
Integer nbCell() const
Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
bool isMasterFace() const
true s'il s'agit de la face maître d'une interface
IItemFamily * family() const
Famille dont est issue l'entité
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
bool isActive() const
Int32 level() const
MutableItemBase toMutable()
Interface modifiable de cette entité
Int32 flags() const
Flags de l'entité
bool isShared() const
Vrai si l'entité est partagé d'autres sous-domaines.
ItemBase backCell() const
Maille derrière l'entité (nullItem() si aucune)
bool isDetached() const
Vrai si l'entité est détachée.
bool hasFlags(Int32 flags) const
Retourne si les flags flags sont positionnées pour l'entité
Integer nbFace() const
Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
bool isSubactive() const
impl::ItemIndexedListView< DynExtent > nodeList() const
Méthodes utilisant les nouvelles connectivités pour accéder aux informations de connectivité....
ItemTypeInfo * typeInfo() const
Type de l'entité.
Int16 typeId() const
Type de l'entité
Int32 nbHParent() const
Nombre de parents pour l'AMR.
bool hasHChildren() const
bool isOwn() const
Vrai si l'entité appartient au sous-domaine.
ItemTypeId itemTypeId() const
Type de l'entité
bool isAncestor() const
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
bool isNull() const
Vrai si l'entité est l'entité nulle.
Integer nbNode() const
Nombre de noeuds de l'entité
ItemBase boundaryCell() const
Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
bool isBoundary() const
true si l'entité est sur la frontière
ItemInternalVectorView internalNodes() const
Méthodes utilisant les nouvelles connectivités pour accéder aux informations de connectivité....
Int32 frontCellId() const
Maille devant l'entité (NULL_ITEM_LOCAL_ID si aucune)
Integer nbParent() const
Nombre de parent pour les sous-maillages.
bool null() const
Vrai si l'entité est l'entité nulle.
ItemBase frontCell() const
Maille devant l'entité (nullItem() si aucune)
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Flags pour les caractéristiques des entités.
Definition ItemFlags.h:38
@ II_FrontCellIsFirst
La première maille de l'entité est la maille devant.
Definition ItemFlags.h:53
@ II_MasterFace
L'entité est une face maître d'une interface.
Definition ItemFlags.h:64
@ II_Inactive
L'entité est inactive //COARSEN_INACTIVE,.
Definition ItemFlags.h:80
@ II_HasBackCell
L'entité a une maille derrière.
Definition ItemFlags.h:52
@ II_Own
L'entité est une entité propre au sous-domaine.
Definition ItemFlags.h:55
@ II_Suppressed
L'entité vient d'être supprimée.
Definition ItemFlags.h:57
@ II_Detached
L'entité est détachée du maillage.
Definition ItemFlags.h:65
@ II_Boundary
L'entité est sur la frontière.
Definition ItemFlags.h:50
@ II_SlaveFace
L'entité est une face esclave d'une interface.
Definition ItemFlags.h:63
@ II_CoarsenInactive
L'entité est inactive et a des enfants tagués pour dé-raffinement.
Definition ItemFlags.h:81
@ II_HasFrontCell
L'entité a une maille devant.
Definition ItemFlags.h:51
@ II_BackCellIsFirst
La première maille de l'entité est la maille derrière.
Definition ItemFlags.h:54
Int32ConstArrayView connectivityNbItem(Int32 item_kind) const
Tableau contenant le nombre d'entités connectées pour les entités de genre item_kind.
Int32ConstArrayView connectivityList(Int32 item_kind) const
Tableau contenant la liste des connectivités pour les entités de genre item_kind.
Int32 maxNbConnectedItem(Int32 item_kind) const
Nombre maximum d'entités connectées.
Int32ConstArrayView connectivityIndex(Int32 item_kind) const
Tableau d'index des connectivités pour les entités de genre item_kind.
constexpr Integer minimumNeededMemory() const
Mémoire minimale nécessaire pour stocker les infos de l'entité (sans tampon)
constexpr Integer neededMemory() const
Mémoire nécessaire pour stocker les infos de l'entité
ItemInternal * boundaryCell() const
Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
ItemSharedInfo * sharedInfo() const
Infos partagées de l'entité.
ItemInternal * frontCell() const
Maille devant l'entité (nullItem() si aucune)
ItemInternal * backCell() const
Maille derrière l'entité (nullItem() si aucune)
static ItemInternal nullItemInternal
Entité nulle.
Int32 * parentPtr()
Pointeur sur la liste des parents.
Index d'une entité ItemType dans une variable.
Definition ItemLocalId.h:90
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Type d'une entité (Item).
Definition ItemTypeId.h:32
Infos sur un type d'entité du maillage.
Identifiant unique d'une entité.
Méthodes permettant de modifier ItemBase.
void setOwner(Integer suid, Int32 current_sub_domain)
Positionne le numéro du sous-domaine propriétaire de l'entité.
void setDetached(bool v)
Positionne l'état détachée de l'entité
void setFlags(Int32 f)
Positionne les flags de l'entité
void unsetUniqueId()
Annule l'uniqueId a la valeur NULL_ITEM_UNIQUE_ID.
void setParent(Int32 aindex, Int32 parent_local_id)
Positionne le i-ème parent (actuellement aindex doit valoir 0)
void addFlags(Int32 added_flags)
Ajoute les flags added_flags à ceux de l'entité
void removeFlags(Int32 removed_flags)
Supprime les flags removed_flags de ceux de l'entité
Noeud d'un maillage.
Definition Item.h:582
Vue d'un tableau d'éléments de type T.
Definition Span.h:673
ItemLocalIdListViewT< Node > NodeLocalIdView
Vue sur les localId() d'une liste de noeuds.
Definition ItemTypes.h:407
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
Active toujours les traces dans les parties Arcane concernant les matériaux.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
eItemKind
Genre d'entité de maillage.
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
std::int32_t Int32
Type entier signé sur 32 bits.