d5/d4d/ItemInternal_8h_source.html

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-

//-----------------------------------------------------------------------------

// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)

// See the top-level COPYRIGHT file for details.

// SPDX-License-Identifier: Apache-2.0

//-----------------------------------------------------------------------------

/*---------------------------------------------------------------------------*/

/* ItemInternal.h                                              (C) 2000-2026 */

/*                                                                           */

/* Internal part of an entity.                                               */

/*---------------------------------------------------------------------------*/

#ifndef ARCANE_CORE_ITEMINTERNAL_H

#define ARCANE_CORE_ITEMINTERNAL_H

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#include "arcane/utils/ArrayView.h"


#include "arcane/core/ItemTypes.h"

#include "arcane/core/ItemIndexedListView.h"

#include "arcane/core/ItemSharedInfo.h"

#include "arcane/core/ItemUniqueId.h"

#include "arcane/core/ItemLocalIdListView.h"

#include "arcane/core/ItemTypeId.h"

#include "arcane/core/ItemFlags.h"

#include "arcane/core/ItemConnectivityContainerView.h"

#include "arcane/core/ItemInternalVectorView.h"


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#ifdef null

#undef null

#endif


//#define ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO


#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

#define A_INTERNAL_SI(name) m_shared_infos.m_##name

#else

#define A_INTERNAL_SI(name) m_items->m_##name##_shared_info

#endif


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane::mesh

{

class IncrementalItemConnectivityBase;

class PolyhedralFamily;

class PolyhedralMeshImpl;

class FaceFamily;

class MeshRefinement;

} // namespace Arcane::mesh

namespace Arcane::Materials

{

class ConstituentItemSharedInfo;

}

namespace Arcane

{

class ItemInternalCompatibility;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_CORE_EXPORT ItemBaseBuildInfo

{

 public:


  ItemBaseBuildInfo() = default;

  constexpr ItemBaseBuildInfo(Int32 local_id, ItemSharedInfo* shared_info)

  : m_local_id(local_id)

  , m_shared_info(shared_info)

  {}


 public:


  Int32 m_local_id = NULL_ITEM_LOCAL_ID;

  ItemSharedInfo* m_shared_info = nullptr;

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_CORE_EXPORT ItemInternalConnectivityList

{

  // IMPORTANT: This structure must have the same memory layout

  // as the C# structure of the same name.


  friend class ItemBase;

  friend class ItemInternal;

  friend class Item;


  // For access to _setConnectivity*

  friend mesh::IncrementalItemConnectivityBase;

  friend mesh::PolyhedralFamily;

  friend mesh::PolyhedralMeshImpl;


  // For access to m_items

  friend mesh::ItemFamily;


 private:


  struct Int32View

  {

   public:


    constexpr Int32 operator[](Int32 index) const

    {

#ifdef ARCANE_CHECK

      if (index == NULL_ITEM_LOCAL_ID) {

        // For the null entity, the size must be 0.

        if (m_size != 0)

          arcaneRangeError(index, m_size);

      }

      else

        ARCANE_CHECK_AT(index, m_size);

#endif

      return m_data[index];

    }

    constexpr void operator=(ConstArrayView<Int32> v)

    {

      m_data = v.data();

      m_size = v.size();

    }

    // data[NULL_ITEM_LOCAL_ID] must be valid.

    // Therefore, (data-1) must point to a valid address

    void setNull(const Int32* data)

    {

      m_data = data;

      m_size = 0;

    }

    operator ConstArrayView<Int32>() const

    {

      return ConstArrayView<Int32>(m_size, m_data);

    }

    operator SmallSpan<const Int32>() const

    {

      return SmallSpan<const Int32>(m_data, m_size);

    }


   private:


    Int32 m_size;

    const Int32* m_data;

  };


 public:


  enum

  {

    NODE_IDX = 0,

    EDGE_IDX = 1,

    FACE_IDX = 2,

    CELL_IDX = 3,

    HPARENT_IDX = 4,

    HCHILD_IDX = 5,

    MAX_ITEM_KIND = 6

  };


 public:


  static ItemInternalConnectivityList nullInstance;


 public:


  ItemInternalConnectivityList()

  : m_items(nullptr)

  {

    for (Integer i = 0; i < MAX_ITEM_KIND; ++i) {

      m_kind_info[i].m_nb_item_null_data[0] = 0;

      m_kind_info[i].m_nb_item_null_data[1] = 0;

      m_kind_info[i].m_max_nb_item = 0;

    }


    for (Integer i = 0; i < MAX_ITEM_KIND; ++i) {

      m_container[i].m_nb_item.setNull(&m_kind_info[i].m_nb_item_null_data[1]);

      m_container[i].m_offset = ConstArrayView<Int32>{};

    }

  }


 public:


  void updateMeshItemInternalList()

  {

#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

    m_shared_infos.m_node = m_items->m_node_shared_info;

    m_shared_infos.m_edge = m_items->m_edge_shared_info;

    m_shared_infos.m_face = m_items->m_face_shared_info;

    m_shared_infos.m_cell = m_items->m_cell_shared_info;

#endif

  }


 private:


  constexpr Int32 itemLocalId(Int32 item_kind, Int32 lid, Integer index) const

  {

    return m_container[item_kind].itemLocalId(lid, index);

  }


  Int64 nbAccess() const { return 0; }

  Int64 nbAccessAll() const { return 0; }


 private:


  void _setConnectivityIndex(Int32 item_kind, ConstArrayView<Int32> v)

  {

    m_container[item_kind].m_indexes = v;

  }


  void _setConnectivityList(Int32 item_kind, ArrayView<Int32> v)

  {

    m_container[item_kind].m_list = v;

    m_container[item_kind].m_offset = ConstArrayView<Int32>{};

  }


  void _setConnectivityNbItem(Int32 item_kind, ConstArrayView<Int32> v)

  {

    m_container[item_kind].m_nb_item = v;

  }


  void _setMaxNbConnectedItem(Int32 item_kind, Int32 v)

  {

    m_kind_info[item_kind].m_max_nb_item = v;

  }


 public:


  ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")


  Int32ConstArrayView connectivityIndex(Int32 item_kind) const

  {

    return m_container[item_kind].m_indexes;

  }


  ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")


  Int32ConstArrayView connectivityList(Int32 item_kind) const

  {

    return m_container[item_kind].m_list;

  }


  ARCANE_DEPRECATED_REASON("Y2022: Use containerView() instead")


  Int32ConstArrayView connectivityNbItem(Int32 item_kind) const

  {

    return m_container[item_kind].m_nb_item;

  }


 public:


  Int32 maxNbConnectedItem(Int32 item_kind) const

  {

    return m_kind_info[item_kind].m_max_nb_item;

  }


  ItemConnectivityContainerView containerView(Int32 item_kind) const

  {

    return m_container[item_kind].containerView();

  }


 public:


  constexpr ItemBaseBuildInfo nodeBase(Int32 lid, Int32 aindex) const

  {

    return ItemBaseBuildInfo(_nodeLocalIdV2(lid, aindex), A_INTERNAL_SI(node));

  }

  constexpr ItemBaseBuildInfo edgeBase(Int32 lid, Int32 aindex) const

  {

    return ItemBaseBuildInfo(_edgeLocalIdV2(lid, aindex), A_INTERNAL_SI(edge));

  }

  constexpr ItemBaseBuildInfo faceBase(Int32 lid, Int32 aindex) const

  {

    return ItemBaseBuildInfo(_faceLocalIdV2(lid, aindex), A_INTERNAL_SI(face));

  }

  constexpr ItemBaseBuildInfo cellBase(Int32 lid, Int32 aindex) const

  {

    return ItemBaseBuildInfo(_cellLocalIdV2(lid, aindex), A_INTERNAL_SI(cell));

  }

  ItemBaseBuildInfo hParentBase(Int32 lid, Int32 aindex, ItemSharedInfo* isf) const

  {

    return ItemBaseBuildInfo(_hParentLocalIdV2(lid, aindex), isf);

  }

  ItemBaseBuildInfo hChildBase(Int32 lid, Int32 aindex, ItemSharedInfo* isf) const

  {

    return ItemBaseBuildInfo(_hChildLocalIdV2(lid, aindex), isf);

  }


  auto nodeList(Int32 lid) const { return impl::ItemIndexedListView{ A_INTERNAL_SI(node), _itemLocalIdListView(NODE_IDX, lid) }; }

  auto edgeList(Int32 lid) const { return impl::ItemIndexedListView{ A_INTERNAL_SI(edge), _itemLocalIdListView(EDGE_IDX, lid) }; }

  auto faceList(Int32 lid) const { return impl::ItemIndexedListView{ A_INTERNAL_SI(face), _itemLocalIdListView(FACE_IDX, lid) }; }

  auto cellList(Int32 lid) const { return impl::ItemIndexedListView{ A_INTERNAL_SI(cell), _itemLocalIdListView(CELL_IDX, lid) }; }


 private:


  // These 4 methods are still used by ItemBase via internalNodes(), internalEdges(), ...

  // They can be removed when these obsolete methods are removed

  ItemInternalVectorView nodesV2(Int32 lid) const { return { A_INTERNAL_SI(node), _itemLocalIdListView(NODE_IDX, lid) }; }

  ItemInternalVectorView edgesV2(Int32 lid) const { return { A_INTERNAL_SI(edge), _itemLocalIdListView(EDGE_IDX, lid) }; }

  ItemInternalVectorView facesV2(Int32 lid) const { return { A_INTERNAL_SI(face), _itemLocalIdListView(FACE_IDX, lid) }; }

  ItemInternalVectorView cellsV2(Int32 lid) const { return { A_INTERNAL_SI(cell), _itemLocalIdListView(CELL_IDX, lid) }; }


  NodeLocalIdView nodeLocalIdsView(Int32 lid) const { return NodeLocalIdView(_itemLocalIdListView(NODE_IDX, lid)); }

  EdgeLocalIdView edgeLocalIdsView(Int32 lid) const { return EdgeLocalIdView(_itemLocalIdListView(EDGE_IDX, lid)); }

  FaceLocalIdView faceLocalIdsView(Int32 lid) const { return FaceLocalIdView(_itemLocalIdListView(FACE_IDX, lid)); }

  CellLocalIdView cellLocalIdsView(Int32 lid) const { return CellLocalIdView(_itemLocalIdListView(CELL_IDX, lid)); }


 private:


  constexpr Int32 _nodeLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(NODE_IDX, lid, index); }

  constexpr Int32 _edgeLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(EDGE_IDX, lid, index); }

  constexpr Int32 _faceLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(FACE_IDX, lid, index); }

  constexpr Int32 _cellLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(CELL_IDX, lid, index); }

  constexpr Int32 _hParentLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(HPARENT_IDX, lid, index); }

  constexpr Int32 _hChildLocalIdV2(Int32 lid, Int32 index) const { return itemLocalId(HCHILD_IDX, lid, index); }


 private:


  ItemInternal* _nodeV2(Int32 lid, Int32 aindex) const { return m_items->nodes[_nodeLocalIdV2(lid, aindex)]; }

  ItemInternal* _edgeV2(Int32 lid, Int32 aindex) const { return m_items->edges[_edgeLocalIdV2(lid, aindex)]; }

  ItemInternal* _faceV2(Int32 lid, Int32 aindex) const { return m_items->faces[_faceLocalIdV2(lid, aindex)]; }

  ItemInternal* _cellV2(Int32 lid, Int32 aindex) const { return m_items->cells[_cellLocalIdV2(lid, aindex)]; }

  ItemInternal* _hParentV2(Int32 lid, Int32 aindex) const { return m_items->cells[_hParentLocalIdV2(lid, aindex)]; }

  ItemInternal* _hChildV2(Int32 lid, Int32 aindex) const { return m_items->cells[_hChildLocalIdV2(lid, aindex)]; }


 private:


  constexpr Int32 _nbNodeV2(Int32 lid) const { return m_container[NODE_IDX].m_nb_item[lid]; }

  constexpr Int32 _nbEdgeV2(Int32 lid) const { return m_container[EDGE_IDX].m_nb_item[lid]; }

  constexpr Int32 _nbFaceV2(Int32 lid) const { return m_container[FACE_IDX].m_nb_item[lid]; }

  constexpr Int32 _nbCellV2(Int32 lid) const { return m_container[CELL_IDX].m_nb_item[lid]; }

  Int32 _nbHParentV2(Int32 lid) const { return m_container[HPARENT_IDX].m_nb_item[lid]; }

  Int32 _nbHChildrenV2(Int32 lid) const { return m_container[HCHILD_IDX].m_nb_item[lid]; }


 private:


  Int32 _nodeOffset(Int32 lid) const { return m_container[NODE_IDX].itemOffset(lid); }

  Int32 _edgeOffset(Int32 lid) const { return m_container[EDGE_IDX].itemOffset(lid); }

  Int32 _faceOffset(Int32 lid) const { return m_container[FACE_IDX].itemOffset(lid); }

  Int32 _cellOffset(Int32 lid) const { return m_container[CELL_IDX].itemOffset(lid); }

  Int32 _itemOffset(Int32 item_kind, Int32 lid) const { return m_container[item_kind].itemOffset(lid); }


 private:


  impl::ItemLocalIdListContainerView _itemLocalIdListView(Int32 item_kind, Int32 lid) const

  {

    return m_container[item_kind].itemLocalIdListView(lid);

  }


 private:


  // NOTE : eventually, this class will be merged with ItemConnectivityContainerView


  struct Container

  {

    impl::ItemLocalIdListContainerView itemLocalIdListView(Int32 lid) const

    {

      return impl::ItemLocalIdListContainerView(itemLocalIdsData(lid), m_nb_item[lid], itemOffset(lid));

    }

    const Int32* itemLocalIdsData(Int32 lid) const

    {

      return &(m_list[m_indexes[lid]]);

    }

    constexpr Int32 itemLocalId(Int32 lid, Integer index) const

    {

      return m_list[m_indexes[lid] + index] + itemOffset(lid);

    }

    ItemConnectivityContainerView containerView() const

    {

      return ItemConnectivityContainerView(m_list, m_indexes, m_nb_item);

    }

    constexpr Int32 itemOffset([[maybe_unused]] Int32 lid) const

    {

#ifdef ARCANE_USE_OFFSET_FOR_CONNECTIVITY

      return m_offset[lid];

#else

      return 0;

#endif

    }


   public:


    ConstArrayView<Int32> m_indexes;

    Int32View m_nb_item;

    ArrayView<Int32> m_list;

    ConstArrayView<Int32> m_offset;

  };


  struct KindInfo

  {

    Int32 m_max_nb_item;

    Int32 m_nb_item_null_data[2];

  };


 private:


  Container m_container[MAX_ITEM_KIND];

  KindInfo m_kind_info[MAX_ITEM_KIND];


  MeshItemInternalList* m_items;


 private:


#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

  impl::MeshItemSharedInfoList m_shared_infos;

#endif

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_CORE_EXPORT ItemBase

: public ItemFlags

{

  friend class ::Arcane::ItemInternal;

  friend class ::Arcane::Item;

  friend class ::Arcane::ItemInternalCompatibility;

  friend Arcane::Materials::ConstituentItemSharedInfo;

  friend class ::Arcane::ItemEnumerator;

  friend MutableItemBase;

  // For _internalActiveCells2().

  friend class ::Arcane::Node;

  // For _itemInternal()

  friend class ::Arcane::mesh::ItemFamily;

  friend class ::Arcane::mesh::MeshRefinement;


 private:


  constexpr ItemBase(Int32 local_id, ItemSharedInfo* shared_info)

  : m_local_id(local_id)

  , m_shared_info(shared_info)

  {}


 public:


  ItemBase()

  : m_shared_info(ItemSharedInfo::nullItemSharedInfoPointer)

  {}

  constexpr ItemBase(ItemBaseBuildInfo x)

  : m_local_id(x.m_local_id)

  , m_shared_info(x.m_shared_info)

  {}


 public:


  // TODO: To be removed eventually

  inline ItemBase(ItemInternal* x);


 public:


  Int32 localId() const { return m_local_id; }

  inline ItemLocalId itemLocalId() const;


  ItemUniqueId uniqueId() const

  {

#ifdef ARCANE_CHECK

    if (m_local_id != NULL_ITEM_LOCAL_ID)

      arcaneCheckAt((Integer)m_local_id, m_shared_info->m_unique_ids.size());

#endif

    // Do not use the normal accessor because this array can be used for the

    // null cell and in this case m_local_id equals NULL_ITEM_LOCAL_ID (which is negative)

    // which causes an array overflow exception.

    return ItemUniqueId(m_shared_info->m_unique_ids.data()[m_local_id]);

  }


  Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }


  Int32 flags() const { return m_shared_info->_flagsV2(m_local_id); }


  Integer nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }

  Integer nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }

  Integer nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }

  Integer nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }

  Int32 nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }

  Int32 nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }

  Integer nbParent() const { return m_shared_info->nbParent(); }


 public:


  Int16 typeId() const { return m_shared_info->_typeId(m_local_id); }

  ItemTypeId itemTypeId() const { return ItemTypeId(typeId()); }

  ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(typeId()); }


  //\p NULL, it is conventionally at level 0; otherwise, it is simply at the

  //level of its parent.


  inline Int32 level() const

  {

    if (this->nbHParent() == 0)

      return 0;

    return (this->hParentBase(0).level() + 1);

  }


  inline bool isAncestor() const

  {

    if (this->isActive())

      return false;

    if (!this->hasHChildren())

      return false;

    if (this->hChildBase(0).isActive())

      return true;

    return this->hChildBase(0).isAncestor();

  }


  inline bool hasHChildren() const

  {

    if (this->nbHChildren() == 0) // TODO ? to check!

      return false;

    else

      return true;

  }


  inline bool isActive() const

  {

    if ((flags() & II_Inactive) | (flags() & II_CoarsenInactive))

      return false;

    else

      return true;

  }


  inline bool isSubactive() const

  {

    if (this->isActive())

      return false;

    if (!this->hasHChildren())

      return true;

    return this->hChildBase(0).isSubactive();

  }


  IItemFamily* family() const { return m_shared_info->m_item_family; }

  eItemKind kind() const { return m_shared_info->m_item_kind; }

  bool null() const { return m_local_id == NULL_ITEM_LOCAL_ID; }

  bool isNull() const { return m_local_id == NULL_ITEM_LOCAL_ID; }

  bool isOwn() const { return ItemFlags::isOwn(flags()); }

  bool isShared() const { return ItemFlags::isShared(flags()); }


  bool isSuppressed() const { return (flags() & II_Suppressed) != 0; }

  bool isDetached() const { return (flags() & II_Detached) != 0; }


  bool isBoundary() const { return ItemFlags::isBoundary(flags()); }

  ItemBase boundaryCell() const { return (flags() & II_Boundary) ? cellBase(0) : ItemBase(); }


  ItemBase backCell() const

  {

    if (flags() & II_HasBackCell)

      return cellBase((flags() & II_BackCellIsFirst) ? 0 : 1);

    return {};

  }


  Int32 backCellId() const

  {

    if (flags() & II_HasBackCell)

      return cellId((flags() & II_BackCellIsFirst) ? 0 : 1);

    return NULL_ITEM_LOCAL_ID;

  }


  ItemBase frontCell() const

  {

    if (flags() & II_HasFrontCell)

      return cellBase((flags() & II_FrontCellIsFirst) ? 0 : 1);

    return {};

  }


  Int32 frontCellId() const

  {

    if (flags() & II_HasFrontCell)

      return cellId((flags() & II_FrontCellIsFirst) ? 0 : 1);

    return NULL_ITEM_LOCAL_ID;

  }


  ItemBase masterFace() const

  {

    if (flags() & II_SlaveFace)

      return faceBase(0);

    return {};

  }

  inline bool isMasterFace() const { return flags() & II_MasterFace; }


  inline bool isSlaveFace() const { return flags() & II_SlaveFace; }


  Int32 parentId(Integer index) const { return m_shared_info->_parentLocalIdV2(m_local_id, index); }


  Int32 nodeId(Integer index) const { return _connectivity()->_nodeLocalIdV2(m_local_id, index); }

  Int32 edgeId(Integer index) const { return _connectivity()->_edgeLocalIdV2(m_local_id, index); }

  Int32 faceId(Integer index) const { return _connectivity()->_faceLocalIdV2(m_local_id, index); }

  Int32 cellId(Integer index) const { return _connectivity()->_cellLocalIdV2(m_local_id, index); }

  Int32 hParentId(Int32 index) const { return _connectivity()->_hParentLocalIdV2(m_local_id, index); }

  Int32 hChildId(Int32 index) const { return _connectivity()->_hChildLocalIdV2(m_local_id, index); }


  ARCANE_DEPRECATED_REASON("Y2023: Use nodeList() instead.")

  ItemInternalVectorView internalNodes() const { return _connectivity()->nodesV2(m_local_id); }

  ARCANE_DEPRECATED_REASON("Y2023: Use edgeList() instead.")

  ItemInternalVectorView internalEdges() const { return _connectivity()->edgesV2(m_local_id); }

  ARCANE_DEPRECATED_REASON("Y2023: Use faceList() instead.")

  ItemInternalVectorView internalFaces() const { return _connectivity()->facesV2(m_local_id); }

  ARCANE_DEPRECATED_REASON("Y2023: Use cellList() instead.")

  ItemInternalVectorView internalCells() const { return _connectivity()->cellsV2(m_local_id); }


  impl::ItemIndexedListView<DynExtent> nodeList() const { return _connectivity()->nodeList(m_local_id); }

  impl::ItemIndexedListView<DynExtent> edgeList() const { return _connectivity()->edgeList(m_local_id); }

  impl::ItemIndexedListView<DynExtent> faceList() const { return _connectivity()->faceList(m_local_id); }

  impl::ItemIndexedListView<DynExtent> cellList() const { return _connectivity()->cellList(m_local_id); }


  impl::ItemIndexedListView<DynExtent> itemList(Node*) const { return nodeList(); }

  impl::ItemIndexedListView<DynExtent> itemList(Edge*) const { return edgeList(); }

  impl::ItemIndexedListView<DynExtent> itemList(Face*) const { return faceList(); }

  impl::ItemIndexedListView<DynExtent> itemList(Cell*) const { return cellList(); }


  ItemBase nodeBase(Int32 index) const { return _connectivity()->nodeBase(m_local_id, index); }

  ItemBase edgeBase(Int32 index) const { return _connectivity()->edgeBase(m_local_id, index); }

  ItemBase faceBase(Int32 index) const { return _connectivity()->faceBase(m_local_id, index); }

  ItemBase cellBase(Int32 index) const { return _connectivity()->cellBase(m_local_id, index); }

  ItemBase hParentBase(Int32 index) const { return _connectivity()->hParentBase(m_local_id, index, m_shared_info); }

  ItemBase hChildBase(Int32 index) const { return _connectivity()->hChildBase(m_local_id, index, m_shared_info); }

  inline ItemBase parentBase(Int32 index) const;


  bool hasFlags(Int32 flags) const { return (this->flags() & flags); }


 public:


  Int32 whichChildAmI(Int32 local_id) const;


 public:


  ItemBase topHParentBase() const;


 public:


  inline MutableItemBase toMutable();


 public:


  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")

  inline ItemInternal* itemInternal() const;


  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane.")

  ItemInternalVectorView _internalActiveCells(Int32Array& local_ids) const

  {

    return _internalActiveCells2(local_ids);

  }


 private:


  Int32 _nbLinearNode() const;


 private:


  Int32 m_local_id = NULL_ITEM_LOCAL_ID;


  Int32 m_padding = 0;


  ItemSharedInfo* m_shared_info = nullptr;


 private:


  ItemInternalConnectivityList* _connectivity() const

  {

    return m_shared_info->m_connectivity;

  }

  void _setFromInternal(ItemBase* rhs)

  {

    m_local_id = rhs->m_local_id;

    m_shared_info = rhs->m_shared_info;

  }

  void _setFromInternal(const ItemBase& rhs)

  {

    m_local_id = rhs.m_local_id;

    m_shared_info = rhs.m_shared_info;

  }

  ItemInternalVectorView _internalActiveCells2(Int32Array& local_ids) const;

  inline ItemInternal* _itemInternal() const;

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_CORE_EXPORT MutableItemBase

: public ItemBase

{

  friend class ::Arcane::Item;

  friend ItemBase;

  // For _setFaceBackAndFrontCell()

  friend Arcane::mesh::FaceFamily;


 private:


  MutableItemBase(Int32 local_id, ItemSharedInfo* shared_info)

  : ItemBase(local_id, shared_info)

  {}


 public:


  MutableItemBase() = default;

  MutableItemBase(ItemBaseBuildInfo x)

  : ItemBase(x)

  {}

  explicit MutableItemBase(const ItemBase& x)

  : ItemBase(x)

  {}


 public:


  // TODO: To be removed eventually

  inline MutableItemBase(ItemInternal* x);


 public:


  void setUniqueId(Int64 uid)

  {

    _checkUniqueId(uid);

    m_shared_info->m_unique_ids[m_local_id] = uid;

  }


  void unsetUniqueId();


  void setOwner(Integer suid, Int32 current_sub_domain)

  {

    m_shared_info->_setOwnerV2(m_local_id, suid);

    int f = flags();

    if (suid == current_sub_domain)

      f |= II_Own;

    else

      f &= ~II_Own;

    setFlags(f);

  }


  void setFlags(Int32 f) { m_shared_info->_setFlagsV2(m_local_id, f); }


  void addFlags(Int32 added_flags)

  {

    Int32 f = this->flags();

    f |= added_flags;

    this->setFlags(f);

  }


  void removeFlags(Int32 removed_flags)

  {

    Int32 f = this->flags();

    f &= ~removed_flags;

    this->setFlags(f);

  }


  void setDetached(bool v)

  {

    int f = flags();

    if (v)

      f |= II_Detached;

    else

      f &= ~II_Detached;

    setFlags(f);

  }


  void reinitialize(Int64 uid, Int32 aowner, Int32 owner_rank)

  {

    setUniqueId(uid);

    setFlags(0);

    setOwner(aowner, owner_rank);

  }


  void setLocalId(Int32 local_id)

  {

    m_local_id = local_id;

  }


  void setParent(Int32 aindex, Int32 parent_local_id)

  {

    m_shared_info->_setParentV2(m_local_id, aindex, parent_local_id);

  }


 private:


  void _setFaceBackAndFrontCells(Int32 back_cell_lid, Int32 front_cell_lid);


  void _checkUniqueId(Int64 new_uid) const;


  inline void _setFaceInfos(Int32 mod_flags);

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_CORE_EXPORT ItemInternal

: public impl::MutableItemBase

{

  // For access to _setSharedInfo()

  friend class mesh::DynamicMeshKindInfos;

  friend class mesh::ItemFamily;


 public:


  static ItemInternal nullItemInternal;

  static ItemInternal* nullItem() { return &nullItemInternal; }


 public:


  // You must use the corresponding method from ItemBase


  ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::boundaryCell() instead.")

  ItemInternal* boundaryCell() const { return (flags() & II_Boundary) ? _internalCell(0) : nullItem(); }

  ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::backCell() instead.")


  ItemInternal* backCell() const

  {

    if (flags() & II_HasBackCell)

      return _internalCell((flags() & II_BackCellIsFirst) ? 0 : 1);

    return nullItem();

  }


  ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::frontCell() instead.")


  ItemInternal* frontCell() const

  {

    if (flags() & II_HasFrontCell)

      return _internalCell((flags() & II_FrontCellIsFirst) ? 0 : 1);

    return nullItem();

  }


  ARCANE_DEPRECATED_REASON("Y2023: use ItemBase::masterFace() instead.")

  ItemInternal* masterFace() const

  {

    if (flags() & II_SlaveFace)

      return _internalFace(0);

    return nullItem();

  }


 public:


  ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")

  ItemSharedInfo* sharedInfo() const { return m_shared_info; }


 public:


  ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")

  ItemInternalVectorView internalItems(Node*) const { return nodeList(); }

  ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")

  ItemInternalVectorView internalItems(Edge*) const { return edgeList(); }

  ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")

  ItemInternalVectorView internalItems(Face*) const { return faceList(); }

  ARCANE_DEPRECATED_REASON("Y2023: Use itemList() instead.")

  ItemInternalVectorView internalItems(Cell*) const { return cellList(); }


 public:


  ARCANE_DEPRECATED_REASON("Y2023: Use nodeBase() instead.")

  ItemInternal* internalNode(Int32 index) const { return _connectivity()->_nodeV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use edgeBase() instead.")

  ItemInternal* internalEdge(Int32 index) const { return _connectivity()->_edgeV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use faceBase() instead.")

  ItemInternal* internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use cellBase() instead.")

  ItemInternal* internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use hParentBase() instead.")

  ItemInternal* internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use hChildBase() instead.")

  ItemInternal* internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use parentBase() instead.")

  ItemInternal* parent(Integer index) const { return m_shared_info->_parentV2(m_local_id, index); }


 public:


  const ItemInternal* topHParent() const;

  ItemInternal* topHParent();


 public:


  ARCANE_DEPRECATED_REASON("Y2022: This method always returns 0")

  Int32 dataIndex() { return 0; }


 public:


  ARCANE_DEPRECATED_REASON("Y2022: Use parentId() or setParent() instead")

  Int32* parentPtr() { return m_shared_info->_parentPtr(m_local_id); }


  Int32 whichChildAmI(const ItemInternal* iitem) const;


 public:


  ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")

  constexpr Integer neededMemory() const { return 0; }


  ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")

  constexpr Integer minimumNeededMemory() const { return 0; }


 public:


  ARCANE_DEPRECATED_REASON("Y2023: Use nodeId() instead")

  Int32 nodeLocalId(Integer index) { return _connectivity()->_nodeLocalIdV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use edgeId() instead")

  Int32 edgeLocalId(Integer index) { return _connectivity()->_edgeLocalIdV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use faceId() instead")

  Int32 faceLocalId(Integer index) { return _connectivity()->_faceLocalIdV2(m_local_id, index); }

  ARCANE_DEPRECATED_REASON("Y2023: Use cellId() instead")

  Int32 cellLocalId(Integer index) { return _connectivity()->_cellLocalIdV2(m_local_id, index); }


 public:


  ARCANE_DEPRECATED_REASON("Y2022: This method always throws an exception.")

  void setDataIndex(Integer);


  ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")

  void setSharedInfo(ItemSharedInfo* shared_infos, ItemTypeId type_id)

  {

    _setSharedInfo(shared_infos, type_id);

  }


 public:


  typedef ItemInternal* ItemInternalPtr;


  ARCANE_DEPRECATED_REASON("Y2022: This method is internal to Arcane and should not be used.")


  static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items)

  {

    return ((items) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());

  }


 private:


  void _setSharedInfo(ItemSharedInfo* shared_infos, ItemTypeId type_id)

  {

    m_shared_info = shared_infos;

    shared_infos->_setTypeId(m_local_id, type_id.typeId());

  }


  ItemInternal* _internalFace(Int32 index) const { return _connectivity()->_faceV2(m_local_id, index); }

  ItemInternal* _internalCell(Int32 index) const { return _connectivity()->_cellV2(m_local_id, index); }

  ItemInternal* _internalHParent(Int32 index) const { return _connectivity()->_hParentV2(m_local_id, index); }

  ItemInternal* _internalHChild(Int32 index) const { return _connectivity()->_hChildV2(m_local_id, index); }

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


ItemBase::

ItemBase(ItemInternal* x)

: m_local_id(x->m_local_id)

, m_shared_info(x->m_shared_info)

{}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


MutableItemBase::

MutableItemBase(ItemInternal* x)

: ItemBase(x)

{}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline ItemLocalId::

ItemLocalId(ItemInternal* item)

: m_local_id(item->localId())

{

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


// TODO: add type check

template <typename ItemType> inline ItemLocalIdT<ItemType>::

ItemLocalIdT(ItemInternal* item)

: ItemLocalId(item->localId())

{

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline ItemInternal* impl::ItemBase::

itemInternal() const

{

  if (m_local_id != NULL_ITEM_LOCAL_ID)

    return m_shared_info->m_items_internal[m_local_id];

  return ItemInternal::nullItem();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline ItemInternal* impl::ItemBase::

_itemInternal() const

{

  if (m_local_id != NULL_ITEM_LOCAL_ID)

    return m_shared_info->m_items_internal[m_local_id];

  return ItemInternal::nullItem();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline impl::ItemBase impl::ItemBase::

parentBase(Int32 index) const

{

  return ItemBase(m_shared_info->_parentV2(m_local_id, index));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline impl::MutableItemBase impl::ItemBase::

toMutable()

{

  return MutableItemBase(m_local_id, m_shared_info);

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


inline ItemLocalId impl::ItemBase::

itemLocalId() const

{

  return ItemLocalId(m_local_id);

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ItemInternalCompatibility

{

  friend class SimdItemBase;

  friend class SimdItemDirectBase;

  friend class SimdItem;

  friend class SimdItemEnumeratorBase;

  friend class ItemVectorView;

  template <typename T> friend class ItemEnumeratorBaseT;

  friend class mesh::DynamicMeshKindInfos;

  friend class TotalviewAdapter;

  template <int Extent> friend class ItemConnectedListView;


 private:


  typedef ItemInternal* ItemInternalPtr;

  static ItemSharedInfo* _getSharedInfo(const ItemInternal* item)

  {

    return item->m_shared_info;

  }

  static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items, Int32 count)

  {

    return ((items && count > 0) ? items[0]->m_shared_info : ItemSharedInfo::nullInstance());

  }

  static const ItemInternalPtr* _getItemInternalPtr(ItemSharedInfo* shared_info)

  {

    ARCANE_CHECK_PTR(shared_info);

    return shared_info->m_items_internal.data();

  }

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


} // End namespace Arcane


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#endif

ItemTypes.h
Declarations of types on entities.

Arcane::ArrayView
Modifiable view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:96

Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550

Arcane::ConstArrayView::data
constexpr const_pointer data() const noexcept
Pointer to the allocated memory.
Definition arccore/src/base/arccore/base/ArrayView.h:785

Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Number of elements in the array.
Definition arccore/src/base/arccore/base/ArrayView.h:739

Arcane::IItemFamily
Interface of an entity family.
Definition IItemFamily.h:83

Arcane::ItemBaseBuildInfo
Class for building an instance of ItemBase.
Definition ItemInternal.h:71

Arcane::ItemBase
Base class for mesh entities.
Definition ItemInternal.h:451

Arcane::ItemBase::nbEdge
Integer nbEdge() const
Number of edges of the entity or number of edges connected to the entity (for nodes).
Definition ItemInternal.h:514

Arcane::ItemBase::itemLocalId
ItemLocalId itemLocalId() const
Local number (in the subdomain) of the entity.
Definition ItemInternal.h:1189

Arcane::ItemBase::isSuppressed
bool isSuppressed() const
True if the entity is suppressed.
Definition ItemInternal.h:613

Arcane::ItemBase::uniqueId
ItemUniqueId uniqueId() const
Unique number of the entity.
Definition ItemInternal.h:493

Arcane::ItemBase::backCellId
Int32 backCellId() const
Cell behind the entity (NULL_ITEM_LOCAL_ID if none).
Definition ItemInternal.h:629

Arcane::ItemBase::m_padding
Int32 m_padding
Field used only to explicitly manage alignment.
Definition ItemInternal.h:768

Arcane::ItemBase::kind
eItemKind kind() const
Kind of the entity.
Definition ItemInternal.h:597

Arcane::ItemBase::nbCell
Integer nbCell() const
Number of cells connected to the entity (for nodes, edges, and faces).
Definition ItemInternal.h:518

Arcane::ItemBase::isMasterFace
bool isMasterFace() const
true if it is the master face of an interface
Definition ItemInternal.h:656

Arcane::ItemBase::family
IItemFamily * family() const
Family the entity belongs to.
Definition ItemInternal.h:595

Arcane::ItemBase::m_local_id
Int32 m_local_id
Local number (in the subdomain) of the entity.
Definition ItemInternal.h:765

Arcane::ItemBase::owner
Int32 owner() const
Number of the owning subdomain of the entity.
Definition ItemInternal.h:506

Arcane::ItemBase::isActive
bool isActive() const
Definition ItemInternal.h:574

Arcane::ItemBase::level
Int32 level() const
Definition ItemInternal.h:538

Arcane::ItemBase::toMutable
MutableItemBase toMutable()
Mutable interface of this entity.
Definition ItemInternal.h:1180

Arcane::ItemBase::flags
Int32 flags() const
Flags of the entity.
Definition ItemInternal.h:509

Arcane::ItemBase::isShared
bool isShared() const
True if the entity is shared by other subdomains.
Definition ItemInternal.h:610

Arcane::ItemBase::backCell
ItemBase backCell() const
Cell behind the entity (nullItem() if none).
Definition ItemInternal.h:622

Arcane::ItemBase::isDetached
bool isDetached() const
True if the entity is detached.
Definition ItemInternal.h:615

Arcane::ItemBase::hasFlags
bool hasFlags(Int32 flags) const
Returns whether the flags flags are set for the entity.
Definition ItemInternal.h:722

Arcane::ItemBase::nbFace
Integer nbFace() const
Number of faces of the entity or number of faces connected to the entity (for nodes and edges).
Definition ItemInternal.h:516

Arcane::ItemBase::isSubactive
bool isSubactive() const
Definition ItemInternal.h:585

Arcane::ItemBase::nodeList
impl::ItemIndexedListView< DynExtent > nodeList() const
Methods using the new connectivities to access connectivity information. Should not be used outside o...
Definition ItemInternal.h:702

Arcane::ItemBase::typeInfo
ItemTypeInfo * typeInfo() const
Type of the entity.
Definition ItemInternal.h:533

Arcane::ItemBase::typeId
Int16 typeId() const
Type of the entity.
Definition ItemInternal.h:529

Arcane::ItemBase::nbHParent
Int32 nbHParent() const
Number of parents for AMR.
Definition ItemInternal.h:520

Arcane::ItemBase::hasHChildren
bool hasHChildren() const
Definition ItemInternal.h:563

Arcane::ItemBase::isOwn
bool isOwn() const
True if the entity belongs to the subdomain.
Definition ItemInternal.h:603

Arcane::ItemBase::itemTypeId
ItemTypeId itemTypeId() const
Type of the entity.
Definition ItemInternal.h:531

Arcane::ItemBase::isAncestor
bool isAncestor() const
Definition ItemInternal.h:551

Arcane::ItemBase::nbHChildren
Int32 nbHChildren() const
Number of children for AMR.
Definition ItemInternal.h:522

Arcane::ItemBase::isNull
bool isNull() const
True if the entity is the null entity.
Definition ItemInternal.h:601

Arcane::ItemBase::nbNode
Integer nbNode() const
Number of nodes of the entity.
Definition ItemInternal.h:512

Arcane::ItemBase::boundaryCell
ItemBase boundaryCell() const
Cell connected to the entity if the entity is a boundary entity (0 if none).
Definition ItemInternal.h:620

Arcane::ItemBase::isBoundary
bool isBoundary() const
true if the entity is on the boundary
Definition ItemInternal.h:618

Arcane::ItemBase::internalNodes
ItemInternalVectorView internalNodes() const
Methods using the new connectivities to access connectivity information. Should not be used outside o...
Definition ItemInternal.h:683

Arcane::ItemBase::m_shared_info
ItemSharedInfo * m_shared_info
Shared info between all entities with the same characteristics.
Definition ItemInternal.h:771

Arcane::ItemBase::frontCellId
Int32 frontCellId() const
Cell in front of the entity (NULL_ITEM_LOCAL_ID if none).
Definition ItemInternal.h:643

Arcane::ItemBase::nbParent
Integer nbParent() const
Number of parent for sub-meshes.
Definition ItemInternal.h:524

Arcane::ItemBase::null
bool null() const
True if the entity is the null entity.
Definition ItemInternal.h:599

Arcane::ItemBase::frontCell
ItemBase frontCell() const
Cell in front of the entity (nullItem() if none).
Definition ItemInternal.h:636

Arcane::ItemBase::localId
Int32 localId() const
Local number (in the subdomain) of the entity.
Definition ItemInternal.h:489

Arcane::ItemBase::isSlaveFace
bool isSlaveFace() const
true if it is a slave face of an interface
Definition ItemInternal.h:659

Arcane::ItemConnectivityContainerView
Views of containers holding connectivity. This class allows the containers used to be opaque outside ...
Definition ItemConnectivityContainerView.h:44

Arcane::ItemFlags
Flags for entity characteristics.
Definition ItemFlags.h:39

Arcane::ItemFlags::II_FrontCellIsFirst
@ II_FrontCellIsFirst
The first cell of the entity is the front cell.
Definition ItemFlags.h:54

Arcane::ItemFlags::II_MasterFace
@ II_MasterFace
The entity is a master face of an interface.
Definition ItemFlags.h:65

Arcane::ItemFlags::II_Inactive
@ II_Inactive
The entity is inactive //COARSEN_INACTIVE,.
Definition ItemFlags.h:80

Arcane::ItemFlags::II_HasBackCell
@ II_HasBackCell
The entity has a back cell.
Definition ItemFlags.h:53

Arcane::ItemFlags::II_Own
@ II_Own
The entity is a domain-specific entity.
Definition ItemFlags.h:56

Arcane::ItemFlags::II_Suppressed
@ II_Suppressed
The entity has just been suppressed.
Definition ItemFlags.h:58

Arcane::ItemFlags::II_Detached
@ II_Detached
The entity is detached from the mesh.
Definition ItemFlags.h:66

Arcane::ItemFlags::II_Boundary
@ II_Boundary
The entity is on the boundary.
Definition ItemFlags.h:51

Arcane::ItemFlags::II_SlaveFace
@ II_SlaveFace
The entity is a slave face of an interface.
Definition ItemFlags.h:64

Arcane::ItemFlags::II_CoarsenInactive
@ II_CoarsenInactive
The entity is inactive and has children tagged for coarsening.
Definition ItemFlags.h:81

Arcane::ItemFlags::II_HasFrontCell
@ II_HasFrontCell
The entity has a front cell.
Definition ItemFlags.h:52

Arcane::ItemFlags::II_BackCellIsFirst
@ II_BackCellIsFirst
The first cell of the entity is the back cell.
Definition ItemFlags.h:55

Arcane::ItemInternalCompatibility
Methods for conversions between different entity management classes.
Definition ItemInternal.h:1205

Arcane::ItemInternalCompatibility::ItemInternalPtr
ItemInternal * ItemInternalPtr
Definition ItemInternal.h:1219

Arcane::ItemInternalConnectivityList
Connectivity information, for an entity family, allowing transition between old and new connectivity ...
Definition ItemInternal.h:95

Arcane::ItemInternalConnectivityList::connectivityNbItem
Int32ConstArrayView connectivityNbItem(Int32 item_kind) const
Array containing the number of connected entities for entities of kind item_kind.
Definition ItemInternal.h:265

Arcane::ItemInternalConnectivityList::nbAccess
Int64 nbAccess() const
Number of calls to itemLocalId().
Definition ItemInternal.h:221

Arcane::ItemInternalConnectivityList::connectivityList
Int32ConstArrayView connectivityList(Int32 item_kind) const
Array containing the connectivity list for entities of kind item_kind.
Definition ItemInternal.h:259

Arcane::ItemInternalConnectivityList::_setConnectivityNbItem
void _setConnectivityNbItem(Int32 item_kind, ConstArrayView< Int32 > v)
Positions the array containing the number of connected entities.
Definition ItemInternal.h:239

Arcane::ItemInternalConnectivityList::itemLocalId
constexpr Int32 itemLocalId(Int32 item_kind, Int32 lid, Integer index) const
localId() of the index-th entity of type item_kind connected to the entity with localid() lid.
Definition ItemInternal.h:216

Arcane::ItemInternalConnectivityList::maxNbConnectedItem
Int32 maxNbConnectedItem(Int32 item_kind) const
Maximum number of connected entities.
Definition ItemInternal.h:273

Arcane::ItemInternalConnectivityList::nbAccessAll
Int64 nbAccessAll() const
Number of calls to itemLocalIds().
Definition ItemInternal.h:223

Arcane::ItemInternalConnectivityList::connectivityIndex
Int32ConstArrayView connectivityIndex(Int32 item_kind) const
Connectivity index array for entities of kind item_kind.
Definition ItemInternal.h:253

Arcane::ItemInternalConnectivityList::_setConnectivityList
void _setConnectivityList(Int32 item_kind, ArrayView< Int32 > v)
Positions the array containing the connectivity list.
Definition ItemInternal.h:233

Arcane::ItemInternalConnectivityList::_setConnectivityIndex
void _setConnectivityIndex(Int32 item_kind, ConstArrayView< Int32 > v)
Positions the connectivity index array.
Definition ItemInternal.h:228

Arcane::ItemInternalConnectivityList::_setMaxNbConnectedItem
void _setMaxNbConnectedItem(Int32 item_kind, Int32 v)
Positions the maximum number of connected entities.
Definition ItemInternal.h:244

Arcane::ItemInternalVectorView
Internal view on an array of entities.
Definition ItemInternalVectorView.h:140

Arcane::ItemInternal
Internal structure of a mesh entity.
Definition ItemInternal.h:942

Arcane::ItemInternal::_getSharedInfo
static ItemSharedInfo * _getSharedInfo(const ItemInternalPtr *items)
Definition ItemInternal.h:1090

Arcane::ItemInternal::ItemInternalPtr
ItemInternal * ItemInternalPtr
Definition ItemInternal.h:1086

Arcane::ItemInternal::minimumNeededMemory
constexpr Integer minimumNeededMemory() const
Minimum memory required to store the entity information (without buffer).
Definition ItemInternal.h:1059

Arcane::ItemInternal::neededMemory
constexpr Integer neededMemory() const
Memory required to store the entity information.
Definition ItemInternal.h:1055

Arcane::ItemInternal::boundaryCell
ItemInternal * boundaryCell() const
Connected cell to the entity if the entity is a boundary entity (0 if none).
Definition ItemInternal.h:959

Arcane::ItemInternal::sharedInfo
ItemSharedInfo * sharedInfo() const
Shared information of the entity.
Definition ItemInternal.h:988

Arcane::ItemInternal::frontCell
ItemInternal * frontCell() const
Cell in front of the entity (nullItem() if none).
Definition ItemInternal.h:970

Arcane::ItemInternal::backCell
ItemInternal * backCell() const
Cell behind the entity (nullItem() if none).
Definition ItemInternal.h:962

Arcane::ItemInternal::nullItemInternal
static ItemInternal nullItemInternal
Null entity.
Definition ItemInternal.h:950

Arcane::ItemInternal::parentPtr
Int32 * parentPtr()
Pointer to the list of parents.
Definition ItemInternal.h:1042

Arcane::ItemLocalIdT
Index of an ItemType entity in a variable.
Definition ItemLocalId.h:92

Arcane::ItemLocalId
Index of an Item in a variable.
Definition ItemLocalId.h:42

Arcane::ItemSharedInfo
Internal shared structure of a mesh entity.
Definition ItemSharedInfo.h:56

Arcane::ItemTypeId
Type of an entity (Item).
Definition ItemTypeId.h:33

Arcane::ItemTypeInfo
Info on a mesh entity type.
Definition ItemTypeInfo.h:46

Arcane::ItemUniqueId
Unique identifier of an entity.
Definition ItemUniqueId.h:35

Arcane::Materials::ConstituentItemSharedInfo
Shared information about 'ComponentItem'.
Definition ConstituentItemSharedInfo.h:118

Arcane::MeshItemInternalList
Indirection tables for mesh entities.
Definition MeshItemInternalList.h:81

Arcane::MutableItemBase
Methods allowing modification of ItemBase.
Definition ItemInternal.h:803

Arcane::MutableItemBase::setOwner
void setOwner(Integer suid, Int32 current_sub_domain)
Sets the sub-domain number of the entity owner.
Definition ItemInternal.h:852

Arcane::MutableItemBase::setDetached
void setDetached(bool v)
Sets the detached state of the entity.
Definition ItemInternal.h:883

Arcane::MutableItemBase::setFlags
void setFlags(Int32 f)
Sets the entity flags.
Definition ItemInternal.h:864

Arcane::MutableItemBase::unsetUniqueId
void unsetUniqueId()
Nullifies the uniqueId to the value NULL_ITEM_UNIQUE_ID.
Definition ItemInternal.cc:53

Arcane::MutableItemBase::setParent
void setParent(Int32 aindex, Int32 parent_local_id)
Sets the i-th parent (currently aindex must be 0).
Definition ItemInternal.h:906

Arcane::MutableItemBase::addFlags
void addFlags(Int32 added_flags)
Adds the flags added_flags to those of the entity.
Definition ItemInternal.h:867

Arcane::MutableItemBase::removeFlags
void removeFlags(Int32 removed_flags)
Removes the flags removed_flags from those of the entity.
Definition ItemInternal.h:875

Arcane::Node
Node of a mesh.
Definition Item.h:598

Arcane::SmallSpan
View of an array of elements of type T.
Definition Span.h:805

Arcane::impl::ItemIndexedListView
Internal view of an array of entities.
Definition ItemIndexedListView.h:44

Arcane::impl::ItemLocalIdListContainerView
View over the container of a list of ItemLocalId.
Definition ItemLocalIdListContainerView.h:40

Arcane::impl::MeshItemSharedInfoList
List of ItemSharedInfo associated with a mesh.
Definition MeshItemInternalList.h:43

Arcane::mesh::DynamicMeshKindInfos
Mesh information for a given entity kind.
Definition DynamicMeshKindInfos.h:52

Arcane::mesh::FaceFamily
Face family.
Definition FaceFamily.h:53

Arcane::mesh::IncrementalItemConnectivityBase
Base class for incremental item->item[] connectivities.
Definition IncrementalItemConnectivity.h:100

Arcane::mesh::ItemFamily
Entity Family.
Definition ItemFamily.h:76

Arcane::mesh::MeshRefinement
Implementation of unstructured mesh refinement adaptation algorithms.
Definition MeshRefinement.h:56

Arcane::mesh::PolyhedralMeshImpl
Definition PolyhedralMesh.cc:2358

Arcane::NodeLocalIdView
ItemLocalIdListViewT< Node > NodeLocalIdView
View over the localId() of a list of nodes.
Definition ItemTypes.h:407

Arcane::EdgeLocalIdView
ItemLocalIdListViewT< Edge > EdgeLocalIdView
View over the localId() of a list of edges.
Definition ItemTypes.h:417

Arcane::FaceLocalIdView
ItemLocalIdListViewT< Face > FaceLocalIdView
View on the localIds() of a list of faces.
Definition ItemTypes.h:427

Arcane::CellLocalIdView
ItemLocalIdListViewT< Cell > CellLocalIdView
View on the localIds() of a list of cells.
Definition ItemTypes.h:437

Arcane::Materials
Always enables tracing in Arcane parts concerning materials.
Definition RunCommandMaterialEnumerate.h:34

Arcane::mesh
AMR.
Definition ArcaneTypes.h:664

Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37

Arcane::Int64
std::int64_t Int64
Signed integer type of 64 bits.
Definition ArccoreGlobal.h:235

Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293

Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
C equivalent of a 1D array of 32-bit integers.
Definition UtilsTypes.h:482

Arcane::eItemKind
eItemKind
Mesh entity type.
Definition ArcaneTypes.h:225

Arcane::Int16
std::int16_t Int16
Signed integer type of 16 bits.
Definition ArccoreGlobal.h:231

Arcane::Int32Array
Array< Int32 > Int32Array
Dynamic one-dimensional array of 32-bit integers.
Definition UtilsTypes.h:127

Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233

Arcane::ItemInternalConnectivityList::Container
Container of views for the connectivity information of a family.
Definition ItemInternal.h:376

Arcane::ItemInternalConnectivityList::Int32View
Specific view to manage null entities.
Definition ItemInternal.h:121

Arcane::ItemInternalConnectivityList::KindInfo
Definition ItemInternal.h:411