d1/dd4/Item_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

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

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

/* Item.h                                                      (C) 2000-2025 */

/*                                                                           */

/* Information about mesh elements.                                          */

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

#ifndef ARCANE_CORE_ITEM_H

#define ARCANE_CORE_ITEM_H

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

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


#include "arcane/core/ItemTypes.h"

#include "arcane/core/ItemInternal.h"

#include "arcane/core/ItemLocalId.h"


#include <atomic>


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

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


namespace Arcane

{


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

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


// Macro to check in Check mode that conversions between the

// entity kinds are correct.

#ifdef ARCANE_CHECK

#define ARCANE_CHECK_KIND(type) _checkKind(type())

#else

#define ARCANE_CHECK_KIND(type)

#endif


#ifdef ARCANE_CHECK

#define ARCANE_WANT_ITEM_STAT

#endif


#ifdef ARCANE_WANT_ITEM_STAT

#define ARCANE_ITEM_ADD_STAT(var) ++var

#else

#define ARCANE_ITEM_ADD_STAT(var)

#endif


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

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


class ARCANE_CORE_EXPORT Item

{

  // To access private constructors

  friend class ItemEnumeratorBaseT<Item>;

  friend class ItemConnectedEnumeratorBaseT<Item>;

  friend class ItemVector;

  friend class ItemVectorView;

  friend class ItemVectorViewConstIterator;

  friend class ItemConnectedListViewConstIterator;

  friend class SimdItem;

  friend class SimdItemEnumeratorBase;

  friend class ItemInfoListView;

  friend class ItemLocalIdToItemConverter;

  template <typename ItemType> friend class ItemLocalIdToItemConverterT;

  friend class ItemPairEnumerator;

  template <int Extent> friend class ItemConnectedListView;

  template <typename ItemType> friend class ItemEnumeratorBaseT;


  // To access _internal()

  friend class ItemCompatibility;


 public:


  typedef ItemInternal* ItemInternalPtr;


  typedef ItemLocalId LocalIdType;


  using ItemBase = impl::ItemBase;


 public:


  class Index

  {

    // TODO Deprecate when we remove

    // the obsolete derived classes.

    // We cannot do this before because it generates too many

    // compilation warnings.

   public:


    Index()

    : m_local_id(NULL_ITEM_LOCAL_ID)

    {}

    explicit Index(Int32 id)

    : m_local_id(id)

    {}

    Index(Item item)

    : m_local_id(item.localId())

    {}

    operator ItemLocalId() const { return ItemLocalId{ m_local_id }; }


   public:


    Int32 localId() const { return m_local_id; }


   private:


    Int32 m_local_id;

  };


 public:


  enum

  {

    Unknown ARCANE_DEPRECATED_REASON("Use 'IT_NullType' instead") = IT_NullType,

    Vertex ARCANE_DEPRECATED_REASON("Use 'IT_Vertex' instead") = IT_Vertex,

    Bar2 ARCANE_DEPRECATED_REASON("Use 'IT_Line2' instead") = IT_Line2,

    Tri3 ARCANE_DEPRECATED_REASON("Use 'IT_Triangle3' instead") = IT_Triangle3,

    Quad4 ARCANE_DEPRECATED_REASON("Use 'IT_Quad4' instead") = IT_Quad4,

    Pentagon5 ARCANE_DEPRECATED_REASON("Use 'IT_Pentagon5' instead") = IT_Pentagon5,

    Hexagon6 ARCANE_DEPRECATED_REASON("Use 'IT_Hexagon6' instead") = IT_Hexagon6,

    Tetra ARCANE_DEPRECATED_REASON("Use 'IT_Tetraedron4' instead") = IT_Tetraedron4,

    Pyramid ARCANE_DEPRECATED_REASON("Use 'IT_Pyramid5' instead") = IT_Pyramid5,

    Penta ARCANE_DEPRECATED_REASON("Use 'IT_Pentaedron6' instead") = IT_Pentaedron6,

    Hexa ARCANE_DEPRECATED_REASON("Use 'IT_Hexaedron8' instead") = IT_Hexaedron8,

    Wedge7 ARCANE_DEPRECATED_REASON("Use 'IT_Heptaedron10' instead") = IT_Heptaedron10,

    Wedge8 ARCANE_DEPRECATED_REASON("Use 'IT_Octaedron12' instead") = IT_Octaedron12

    // Reduced to minimum for compatibility.

  };


  static const Int32 NULL_ELEMENT = NULL_ITEM_ID;


  ARCCORE_DEPRECATED_2021("Use ItemTypeMng::typeName() instead")

  static String typeName(Int32 type);


 protected:


  constexpr ARCCORE_HOST_DEVICE Item(Int32 local_id, ItemSharedInfo* shared_info)

  : m_shared_info(shared_info)

  , m_local_id(local_id)

  {}


 public:


  Item() = default;


  //ARCANE_DEPRECATED_REASON("Remove this overload")


  Item(ItemInternal* ainternal)

  {

    ARCANE_CHECK_PTR(ainternal);

    m_shared_info = ainternal->m_shared_info;

    m_local_id = ainternal->m_local_id;

    ARCANE_ITEM_ADD_STAT(m_nb_created_from_internal);

  }


  // NOTE: For the following constructor; it is essential to use

  // const& to avoid ambiguity with the copy constructor


  constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase)

  : m_shared_info(abase.m_shared_info)

  , m_local_id(abase.m_local_id)

  {

  }


  Item(const ItemInternalPtr* internals, Int32 local_id)

  : Item(local_id, internals[local_id]->m_shared_info)

  {

    ARCANE_ITEM_ADD_STAT(m_nb_created_from_internalptr);

  }


  Item& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr bool null() const { return m_local_id == NULL_ITEM_ID; }


  constexpr Int32 localId() const { return m_local_id; }


  constexpr ItemLocalId itemLocalId() const { return ItemLocalId{ m_local_id }; }


  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 may be used for the

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

    // which causes an exception for array overflow.

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

  }


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


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


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


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


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


  constexpr bool isOwn() const { return (_flags() & ItemFlags::II_Own) != 0; }


  bool isShared() const { return (_flags() & ItemFlags::II_Shared) != 0; }


  inline ItemWithNodes toItemWithNodes() const;

  inline Node toNode() const;

  inline Cell toCell() const;

  inline Edge toEdge() const;

  inline Face toFace() const;

  inline Particle toParticle() const;

  inline DoF toDoF() const;


  Int32 nbParent() const { return _nbParent(); }


  Item parent(Int32 i) const { return m_shared_info->_parentV2(m_local_id, i); }


  Item parent() const { return m_shared_info->_parentV2(m_local_id, 0); }


 public:


  constexpr bool isItemWithNodes() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Edge || ik == IK_Face || ik == IK_Cell);

  }


  constexpr bool isNode() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Node);

  }


  constexpr bool isCell() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Cell);

  }


  constexpr bool isEdge() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Edge);

  }


  constexpr bool isFace() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Face);

  }


  constexpr bool isParticle() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_Particle);

  }


  constexpr


  bool isDoF() const

  {

    eItemKind ik = kind();

    return (ik == IK_Unknown || ik == IK_DoF);

  }


  constexpr bool hasFlags(Int32 flags) const { return (_flags() & flags); }


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


 public:


  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. use itemBase() or mutableItemBase() instead")


  ItemInternal* internal() const

  {

    if (m_local_id != NULL_ITEM_LOCAL_ID)

      return m_shared_info->m_items_internal[m_local_id];

    return ItemInternal::nullItem();

  }


 public:


  impl::ItemBase itemBase() const

  {

    return impl::ItemBase(m_local_id, m_shared_info);

  }


  impl::MutableItemBase mutableItemBase() const

  {

    return impl::MutableItemBase(m_local_id, m_shared_info);

  }


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


 public:


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Item* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Item* operator->() const { return this; }


 private:


  ItemSharedInfo* m_shared_info = ItemSharedInfo::nullItemSharedInfoPointer;


 protected:


  Int32 m_local_id = NULL_ITEM_LOCAL_ID;


 protected:


  constexpr void _checkKind(bool is_valid) const

  {

    if (!is_valid)

      _badConversion();

  }

  [[noreturn]] void _badConversion() const;

  void _set(ItemInternal* ainternal)

  {

    _setFromInternal(ainternal);

  }

  constexpr void _set(const Item& rhs)

  {

    _setFromItem(rhs);

  }


 protected:


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

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

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

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

  constexpr 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(); }

  constexpr NodeLocalId _nodeId(Int32 index) const { return NodeLocalId(_connectivity()->_nodeLocalIdV2(m_local_id, index)); }

  constexpr EdgeLocalId _edgeId(Int32 index) const { return EdgeLocalId(_connectivity()->_edgeLocalIdV2(m_local_id, index)); }

  constexpr FaceLocalId _faceId(Int32 index) const { return FaceLocalId(_connectivity()->_faceLocalIdV2(m_local_id, index)); }

  constexpr CellLocalId _cellId(Int32 index) const { return CellLocalId(_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); }

  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); }

  NodeLocalIdView _nodeIds() const { return _connectivity()->nodeLocalIdsView(m_local_id); }

  EdgeLocalIdView _edgeIds() const { return _connectivity()->edgeLocalIdsView(m_local_id); }

  FaceLocalIdView _faceIds() const { return _connectivity()->faceLocalIdsView(m_local_id); }

  CellLocalIdView _cellIds() const { return _connectivity()->cellLocalIdsView(m_local_id); }


  constexpr inline Node _node(Int32 index) const;

  constexpr inline Edge _edge(Int32 index) const;

  constexpr inline Face _face(Int32 index) const;

  constexpr inline Cell _cell(Int32 index) const;


  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); }

  ItemBase _toItemBase() const { return ItemBase(m_local_id, m_shared_info); }


  Int32 _nbLinearNode() const { return itemBase()._nbLinearNode(); }


 private:


  constexpr ItemInternalConnectivityList* _connectivity() const

  {

    return m_shared_info->m_connectivity;

  }

  void _setFromInternal(ItemBase* rhs)

  {

    ARCANE_ITEM_ADD_STAT(m_nb_set_from_internal);

    m_local_id = rhs->m_local_id;

    m_shared_info = rhs->m_shared_info;

  }

  constexpr void _setFromItem(const Item& rhs)

  {

    m_local_id = rhs.m_local_id;

    m_shared_info = rhs.m_shared_info;

  }


 public:


  static void dumpStats(ITraceMng* tm);

  static void resetStats();


 private:


  static std::atomic<int> m_nb_created_from_internal;

  static std::atomic<int> m_nb_created_from_internalptr;

  static std::atomic<int> m_nb_set_from_internal;


 private:


  ItemInternal* _internal() const

  {

    if (m_local_id != NULL_ITEM_LOCAL_ID)

      return m_shared_info->m_items_internal[m_local_id];

    return ItemInternal::nullItem();

  }

};


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

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


inline bool


operator==(const Item& item1, const Item& item2)

{

  return item1.localId() == item2.localId();

}


inline bool


operator!=(const Item& item1, const Item& item2)

{

  return item1.localId() != item2.localId();

}


inline bool

operator<(const Item& item1, const Item& item2)

{

  return item1.localId() < item2.localId();

}


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

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


} // End namespace Arcane


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

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


#include "arcane/core/ItemVectorView.h"

#include "arcane/core/ItemConnectedListView.h"


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

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


namespace Arcane

{


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

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


class ARCANE_CORE_EXPORT Node

: public Item

{

  using ThatClass = Node;

  // For accessing private constructors

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 public:


  class ARCANE_DEPRECATED_REASON("Y2024: Use NodeLocalId instead") Index

  : public Item::Index

  {

   public:


    typedef Item::Index Base;


   public:


    explicit Index(Int32 id)

    : Base(id)

    {}

    Index(Node item)

    : Base(item)

    {}

    operator NodeLocalId() const { return NodeLocalId{ localId() }; }

  };


 protected:


  constexpr Node(Int32 local_id, ItemSharedInfo* shared_info)

  : Item(local_id, shared_info)

  {}


 public:


  typedef NodeLocalId LocalIdType;


  Node() = default;


  Node(ItemInternal* ainternal)

  : Item(ainternal)

  {

    ARCANE_CHECK_KIND(isNode);

  }


  constexpr Node(const ItemBase& abase)

  : Item(abase)

  {

    ARCANE_CHECK_KIND(isNode);

  }


  constexpr explicit Node(const Item& aitem)

  : Item(aitem)

  {

    ARCANE_CHECK_KIND(isNode);

  }


  Node(const ItemInternalPtr* internals, Int32 local_id)

  : Item(internals, local_id)

  {

    ARCANE_CHECK_KIND(isNode);

  }


  Node& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr eItemKind kind() const { return IK_Node; }


  constexpr NodeLocalId itemLocalId() const { return NodeLocalId{ m_local_id }; }


  constexpr Int32 nbEdge() const { return _nbEdge(); }


  constexpr Int32 nbFace() const { return _nbFace(); }


  Int32 nbCell() const { return _nbCell(); }


  inline Edge edge(Int32 i) const;


  inline Face face(Int32 i) const;


  inline Cell cell(Int32 i) const;


  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }


  FaceLocalId faceId(Int32 i) const { return _faceId(i); }


  CellLocalId cellId(Int32 i) const { return _cellId(i); }


  EdgeConnectedListViewType edges() const { return _edgeList(); }


  FaceConnectedListViewType faces() const { return _faceList(); }


  CellConnectedListViewType cells() const { return _cellList(); }


  EdgeLocalIdView edgeIds() const { return _edgeIds(); }


  FaceLocalIdView faceIds() const { return _faceIds(); }


  CellLocalIdView cellIds() const { return _cellIds(); }


  // AMR


  CellVectorView _internalActiveCells(Int32Array& local_ids) const

  {

    return _toItemBase()._internalActiveCells2(local_ids);

  }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Node* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Node* operator->() const { return this; }

};


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

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


constexpr inline Node Item::

_node(Int32 index) const

{

  return Node(_connectivity()->nodeBase(m_local_id, index));

}


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

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


class ARCANE_CORE_EXPORT ItemWithNodes

: public Item

{

  using ThatClass = ItemWithNodes;

  // For accessing private constructors

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 protected:


  constexpr ItemWithNodes(Int32 local_id, ItemSharedInfo* shared_info)

  : Item(local_id, shared_info)

  {}


 public:


  ItemWithNodes() = default;


  ItemWithNodes(ItemInternal* ainternal)

  : Item(ainternal)

  {

    ARCANE_CHECK_KIND(isItemWithNodes);

  }


  constexpr ItemWithNodes(const ItemBase& abase)

  : Item(abase)

  {

    ARCANE_CHECK_KIND(isItemWithNodes);

  }


  constexpr explicit ItemWithNodes(const Item& aitem)

  : Item(aitem)

  {

    ARCANE_CHECK_KIND(isItemWithNodes);

  }


  ItemWithNodes(const ItemInternalPtr* internals, Int32 local_id)

  : Item(internals, local_id)

  {

    ARCANE_CHECK_KIND(isItemWithNodes);

  }


  ItemWithNodes& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  Int32 nbNode() const { return _nbNode(); }


  Node node(Int32 i) const { return _node(i); }


  NodeConnectedListViewType nodes() const { return _nodeList(); }


  NodeLocalIdView nodeIds() const { return _nodeIds(); }


  NodeLocalId nodeId(Int32 index) const { return _nodeId(index); }


  Int32 nbLinearNode() const { return _nbLinearNode(); }


 public:


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  ItemWithNodes* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const ItemWithNodes* operator->() const { return this; }

};


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

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


class ARCANE_CORE_EXPORT Edge

: public ItemWithNodes

{

  using ThatClass = Edge;

  // For accessing private constructors

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 public:


  class ARCANE_DEPRECATED_REASON("Y2024: Use EdgeLocalId instead") Index

  : public Item::Index

  {

   public:


    typedef Item::Index Base;


   public:


    explicit Index(Int32 id)

    : Base(id)

    {}

    Index(Edge item)

    : Base(item)

    {}

    operator EdgeLocalId() const { return EdgeLocalId{ localId() }; }

  };


 private:


  Edge(Int32 local_id, ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id, shared_info)

  {}


 public:


  typedef EdgeLocalId LocalIdType;


  Edge() = default;


  Edge(ItemInternal* ainternal)

  : ItemWithNodes(ainternal)

  {

    ARCANE_CHECK_KIND(isEdge);

  }


  constexpr Edge(const ItemBase& abase)

  : ItemWithNodes(abase)

  {

    ARCANE_CHECK_KIND(isEdge);

  }


  constexpr explicit Edge(const Item& aitem)

  : ItemWithNodes(aitem)

  {

    ARCANE_CHECK_KIND(isEdge);

  }


  Edge(const ItemInternalPtr* internals, Int32 local_id)

  : ItemWithNodes(internals, local_id)

  {

    ARCANE_CHECK_KIND(isEdge);

  }


  Edge& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr eItemKind kind() const { return IK_Edge; }


  EdgeLocalId itemLocalId() const { return EdgeLocalId{ m_local_id }; }


  Int32 nbNode() const { return 2; }


  Int32 nbFace() const { return _nbFace(); }


  Int32 nbCell() const { return _nbCell(); }


  inline Cell cell(Int32 i) const;


  CellConnectedListViewType cells() const { return _cellList(); }


  CellLocalId cellId(Int32 i) const { return _cellId(i); }


  CellLocalIdView cellIds() const { return _cellIds(); }


  inline Face face(Int32 i) const;


  FaceConnectedListViewType faces() const { return _faceList(); }


  FaceLocalId faceId(Int32 i) const { return _faceId(i); }


  FaceLocalIdView faceIds() const { return _faceIds(); }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Edge* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Edge* operator->() const { return this; }

};


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

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


constexpr inline Edge Item::

_edge(Int32 index) const

{

  return Edge(_connectivity()->edgeBase(m_local_id, index));

}


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

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


class ARCANE_CORE_EXPORT Face

: public ItemWithNodes

{

  using ThatClass = Face;

  // To access private constructors

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 public:


  class ARCANE_DEPRECATED_REASON("Y2024: Use FaceLocalId instead") Index

  : public Item::Index

  {

   public:


    typedef Item::Index Base;


   public:


    explicit Index(Int32 id)

    : Base(id)

    {}

    Index(Face item)

    : Base(item)

    {}

    operator FaceLocalId() const { return FaceLocalId{ localId() }; }

  };


 private:


  constexpr Face(Int32 local_id, ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id, shared_info)

  {}


 public:


  typedef FaceLocalId LocalIdType;


  Face() = default;


  Face(ItemInternal* ainternal)

  : ItemWithNodes(ainternal)

  {

    ARCANE_CHECK_KIND(isFace);

  }


  constexpr Face(const ItemBase& abase)

  : ItemWithNodes(abase)

  {

    ARCANE_CHECK_KIND(isFace);

  }


  constexpr explicit Face(const Item& aitem)

  : ItemWithNodes(aitem)

  {

    ARCANE_CHECK_KIND(isFace);

  }


  Face(const ItemInternalPtr* internals, Int32 local_id)

  : ItemWithNodes(internals, local_id)

  {

    ARCANE_CHECK_KIND(isFace);

  }


  Face& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr eItemKind kind() const { return IK_Face; }


  FaceLocalId itemLocalId() const { return FaceLocalId{ m_local_id }; }


  Int32 nbCell() const { return _nbCell(); }


  inline Cell cell(Int32 i) const;


  CellConnectedListViewType cells() const { return _cellList(); }


  CellLocalId cellId(Int32 i) const { return _cellId(i); }


  CellLocalIdView cellIds() const { return _cellIds(); }


  bool isSubDomainBoundary() const { return (_flags() & ItemFlags::II_Boundary) != 0; }


  ARCANE_DEPRECATED_118 bool isBoundary() const { return isSubDomainBoundary(); }


  bool isSubDomainBoundaryOutside() const

  {

    return isSubDomainBoundary() && (_flags() & ItemFlags::II_HasBackCell);

  }


  ARCANE_DEPRECATED_118 bool isBoundaryOutside() const

  {

    return isSubDomainBoundaryOutside();

  }


  inline Cell boundaryCell() const;


  inline Cell backCell() const;


  CellLocalId backCellId() const { return CellLocalId(_toItemBase().backCellId()); }


  inline Cell frontCell() const;


  CellLocalId frontCellId() const { return CellLocalId(_toItemBase().frontCellId()); }


  inline Cell oppositeCell(Cell cell) const;


  CellLocalId oppositeCellId(CellLocalId cell_id) const

  {

    ARCANE_ASSERT((backCellId() == cell_id || frontCellId() == cell_id), ("cell is not connected to the face"));

    return (backCellId() == cell_id) ? frontCellId() : backCellId();

  }


  Face masterFace() const { return _toItemBase().masterFace(); }


  bool isMasterFace() const { return _toItemBase().isMasterFace(); }


  bool isSlaveFace() const { return _toItemBase().isSlaveFace(); }


  bool isTiedFace() const { return isSlaveFace() || isMasterFace(); }


  FaceConnectedListViewType slaveFaces() const

  {

    if (_toItemBase().isMasterFace())

      return _faceList();

    return FaceConnectedListViewType();

  }


 public:


  Int32 nbEdge() const { return _nbEdge(); }


  Edge edge(Int32 i) const { return _edge(i); }


  EdgeConnectedListViewType edges() const { return _edgeList(); }


  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }


  EdgeLocalIdView edgeIds() const { return _edgeIds(); }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Face* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Face* operator->() const { return this; }

};


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

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


constexpr inline Face Item::

_face(Int32 index) const

{

  return Face(_connectivity()->faceBase(m_local_id, index));

}


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

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


class ARCANE_CORE_EXPORT Cell

: public ItemWithNodes

{

  using ThatClass = Cell;

  // To access private constructors

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 public:


  class ARCANE_DEPRECATED_REASON("Y2024: Use CellLocalId instead") Index

  : public Item::Index

  {

   public:


    typedef Item::Index Base;


   public:


    explicit Index(Int32 id)

    : Base(id)

    {}

    Index(Cell item)

    : Base(item)

    {}

    operator CellLocalId() const { return CellLocalId{ localId() }; }

  };


 private:


  Cell(Int32 local_id, ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id, shared_info)

  {}


 public:


  typedef CellLocalId LocalIdType;


  Cell() = default;


  Cell(ItemInternal* ainternal)

  : ItemWithNodes(ainternal)

  {

    ARCANE_CHECK_KIND(isCell);

  }


  constexpr Cell(const ItemBase& abase)

  : ItemWithNodes(abase)

  {

    ARCANE_CHECK_KIND(isCell);

  }


  constexpr explicit Cell(const Item& aitem)

  : ItemWithNodes(aitem)

  {

    ARCANE_CHECK_KIND(isCell);

  }


  Cell(const ItemInternalPtr* internals, Int32 local_id)

  : ItemWithNodes(internals, local_id)

  {

    ARCANE_CHECK_KIND(isCell);

  }


  Cell& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr eItemKind kind() const { return IK_Cell; }


  CellLocalId itemLocalId() const { return CellLocalId{ m_local_id }; }


  Int32 nbFace() const { return _nbFace(); }


  Face face(Int32 i) const { return _face(i); }


  FaceConnectedListViewType faces() const { return _faceList(); }


  FaceLocalId faceId(Int32 i) const { return _faceId(i); }


  FaceLocalIdView faceIds() const { return _faceIds(); }


  Int32 nbEdge() const { return _nbEdge(); }


  Edge edge(Int32 i) const { return _edge(i); }


  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }


  EdgeConnectedListViewType edges() const { return _edgeList(); }


  EdgeLocalIdView edgeIds() const { return _edgeIds(); }


  Cell hParent() const { return Cell(_hParentBase(0)); }


  Int32 nbHParent() const { return _nbHParent(); }


  Int32 nbHChildren() const { return _nbHChildren(); }


  Cell hChild(Int32 i) const { return Cell(_hChildBase(i)); }


  Cell topHParent() const { return Cell(_toItemBase().topHParentBase()); }


  bool isActive() const { return _toItemBase().isActive(); }


  bool isSubactive() const { return _toItemBase().isSubactive(); }


  bool isAncestor() const { return _toItemBase().isAncestor(); }


  bool hasHChildren() const { return _toItemBase().hasHChildren(); }


  Int32 level() const

  {

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

      return 0;

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

  }


  Int32 whichChildAmI(const ItemInternal* iitem) const

  {

    return _toItemBase().whichChildAmI(iitem->localId());

  }


  Int32 whichChildAmI(CellLocalId local_id) const

  {

    return _toItemBase().whichChildAmI(local_id);

  }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Cell* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Cell* operator->() const { return this; }

};


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

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


constexpr inline Cell Item::

_cell(Int32 index) const

{

  return Cell(_connectivity()->cellBase(m_local_id, index));

}


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

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


class Particle

: public Item

{

  using ThatClass = Particle;

  // Pour accéder aux constructeurs privés

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 private:


  Particle(Int32 local_id, ItemSharedInfo* shared_info)

  : Item(local_id, shared_info)

  {}


 public:


  typedef ParticleLocalId LocalIdType;


  Particle() = default;


  Particle(ItemInternal* ainternal)

  : Item(ainternal)

  {

    ARCANE_CHECK_KIND(isParticle);

  }


  constexpr Particle(const ItemBase& abase)

  : Item(abase)

  {

    ARCANE_CHECK_KIND(isParticle);

  }


  constexpr explicit Particle(const Item& aitem)

  : Item(aitem)

  {

    ARCANE_CHECK_KIND(isParticle);

  }


  Particle(const ItemInternalPtr* internals, Int32 local_id)

  : Item(internals, local_id)

  {

    ARCANE_CHECK_KIND(isParticle);

  }


  Particle& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


 public:


  constexpr eItemKind kind() const { return IK_Particle; }


  ParticleLocalId itemLocalId() const { return ParticleLocalId{ m_local_id }; }


  Cell cell() const { return _cell(0); }


  CellLocalId cellId() const { return _cellId(0); }


  bool hasCell() const { return (_cellId(0).localId() != NULL_ITEM_LOCAL_ID); }


  Cell cellOrNull() const

  {

    Int32 cell_local_id = _cellId(0).localId();

    if (cell_local_id == NULL_ITEM_LOCAL_ID)

      return Cell();

    return _cell(0);

  }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  Particle* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const Particle* operator->() const { return this; }

};


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

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


class DoF

: public Item

{

  using ThatClass = DoF;

  // Pour accéder aux constructeurs privés

  friend class ItemEnumeratorBaseT<ThatClass>;

  friend class ItemConnectedEnumeratorBaseT<ThatClass>;

  friend class ItemVectorT<ThatClass>;

  friend class ItemVectorViewT<ThatClass>;

  friend class ItemConnectedListViewT<ThatClass>;

  friend class ItemVectorViewConstIteratorT<ThatClass>;

  friend class ItemConnectedListViewConstIteratorT<ThatClass>;

  friend class SimdItemT<ThatClass>;

  friend class ItemInfoListViewT<ThatClass>;

  friend class ItemLocalIdToItemConverterT<ThatClass>;


 private:


  constexpr DoF(Int32 local_id, ItemSharedInfo* shared_info)

  : Item(local_id, shared_info)

  {}


 public:


  using LocalIdType = DoFLocalId;


  DoF() = default;


  DoF(ItemInternal* ainternal)

  : Item(ainternal)

  {

    ARCANE_CHECK_KIND(isDoF);

  }


  constexpr DoF(const ItemBase& abase)

  : Item(abase)

  {

    ARCANE_CHECK_KIND(isDoF);

  }


  constexpr explicit DoF(const Item& aitem)

  : Item(aitem)

  {

    ARCANE_CHECK_KIND(isDoF);

  }


  DoF(const ItemInternalPtr* internals, Int32 local_id)

  : Item(internals, local_id)

  {

    ARCANE_CHECK_KIND(isDoF);

  }


  DoF& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  DoF* operator->() { return this; }


  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")

  const DoF* operator->() const { return this; }


  constexpr eItemKind kind() const { return IK_DoF; }


  DoFLocalId itemLocalId() const { return DoFLocalId{ m_local_id }; }

};


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

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


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

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


inline Edge Node::

edge(Int32 i) const

{

  return _edge(i);

}


inline Face Node::

face(Int32 i) const

{

  return _face(i);

}


inline Cell Node::

cell(Int32 i) const

{

  return _cell(i);

}


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

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


inline Face Edge::

face(Int32 i) const

{

  return _face(i);

}


inline Cell Edge::

cell(Int32 i) const

{

  return _cell(i);

}


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

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


inline Cell Face::

boundaryCell() const

{

  return Cell(_toItemBase().boundaryCell());

}


inline Cell Face::

backCell() const

{

  return Cell(_toItemBase().backCell());

}


inline Cell Face::

frontCell() const

{

  return Cell(_toItemBase().frontCell());

}


inline Cell Face::

oppositeCell(Cell cell) const

{

  ARCANE_ASSERT((backCell() == cell || frontCell() == cell), ("cell is not connected to the face"));

  return (backCell() == cell) ? frontCell() : backCell();

}


inline Cell Face::

cell(Int32 i) const

{

  return _cell(i);

}


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

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


inline ItemWithNodes Item::

toItemWithNodes() const

{

  ARCANE_CHECK_KIND(isItemWithNodes);

  return ItemWithNodes(*this);

}


inline Node Item::

toNode() const

{

  ARCANE_CHECK_KIND(isNode);

  return Node(*this);

}


inline Edge Item::

toEdge() const

{

  ARCANE_CHECK_KIND(isEdge);

  return Edge(*this);

}


inline Face Item::

toFace() const

{

  ARCANE_CHECK_KIND(isFace);

  return Face(*this);

}


inline Cell Item::

toCell() const

{

  ARCANE_CHECK_KIND(isCell);

  return Cell(*this);

}


inline Particle Item::

toParticle() const

{

  ARCANE_CHECK_KIND(isParticle);

  return Particle(*this);

}


inline DoF Item::

toDoF() const

{

  ARCANE_CHECK_KIND(isDoF);

  return DoF(*this);

}


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

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


inline ItemLocalId::

ItemLocalId(Item item)

: m_local_id(item.localId())

{

}


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

ItemLocalIdT(ItemType item)

: ItemLocalId(item.localId())

{

}


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

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


inline Item ItemInfoListView::

operator[](ItemLocalId local_id) const

{

  return Item(local_id.localId(), m_item_shared_info);

}


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

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


inline Item ItemInfoListView::

operator[](Int32 local_id) const

{

  return Item(local_id, m_item_shared_info);

}


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

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


template <typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::

operator[](ItemLocalId local_id) const

{

  return ItemType(local_id.localId(), m_item_shared_info);

}


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

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


template <typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::

operator[](Int32 local_id) const

{

  return ItemType(local_id, m_item_shared_info);

}


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

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


inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::

operator[](ItemLocalId local_id) const

{

  return Item(local_id.localId(), m_item_shared_info);

}


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

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


inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::

operator[](Int32 local_id) const

{

  return Item(local_id, m_item_shared_info);

}


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

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


template <typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_


ItemLocalIdToItemConverterT<ItemType_>::

operator[](ItemLocalIdType local_id) const

{

  return ItemType(local_id.localId(), m_item_shared_info);

}


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

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


template <typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_


ItemLocalIdToItemConverterT<ItemType_>::

operator[](Int32 local_id) const

{

  return ItemType(local_id, m_item_shared_info);

}


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

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


} // End namespace Arcane


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

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


#include "arcane/core/ItemCompatibility.h"


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

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


#endif


ItemTypes.h
Declarations of types on entities.

Arcane::Cell
Cell of a mesh.
Definition Item.h:1300

Arcane::Cell::topHParent
Cell topHParent() const
level 0 parent for AMR
Definition Item.h:1444

Arcane::Cell::nbEdge
Int32 nbEdge() const
Number of edges of the cell.
Definition Item.h:1412

Arcane::Cell::Cell
constexpr Cell(const ItemBase &abase)
Constructs a reference to the base entity.
Definition Item.h:1361

Arcane::Cell::faces
FaceConnectedListViewType faces() const
List of faces of the cell.
Definition Item.h:1403

Arcane::Cell::nbHChildren
Int32 nbHChildren() const
Number of children for AMR.
Definition Item.h:1438

Arcane::Cell::isAncestor
bool isAncestor() const
Definition Item.h:1460

Arcane::Cell::Cell
Cell(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:1341

Arcane::Cell::face
Face face(Int32 i) const
i-th face of the cell
Definition Item.h:1400

Arcane::Cell::faceIds
FaceLocalIdView faceIds() const
List of faces of the cell.
Definition Item.h:1409

Arcane::Cell::Cell
Cell(ItemInternal *ainternal)
(deprecated) Constructs a reference to the internal entity
Definition Item.h:1354

Arcane::Cell::nbFace
Int32 nbFace() const
Number of faces of the cell.
Definition Item.h:1397

Arcane::Cell::operator=
Cell & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:1382

Arcane::Cell::Cell
Cell(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the internal entity.
Definition Item.h:1375

Arcane::Cell::itemLocalId
CellLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:1394

Arcane::Cell::edgeIds
EdgeLocalIdView edgeIds() const
List of edges of the cell.
Definition Item.h:1424

Arcane::Cell::edgeId
EdgeLocalId edgeId(Int32 i) const
i-th edge of the cell
Definition Item.h:1418

Arcane::Cell::whichChildAmI
Int32 whichChildAmI(const ItemInternal *iitem) const
Definition Item.h:1489

Arcane::Cell::Cell
constexpr Cell(const Item &aitem)
Constructs a reference to the item entity.
Definition Item.h:1368

Arcane::Cell::hChild
Cell hChild(Int32 i) const
i-th AMR child
Definition Item.h:1441

Arcane::Cell::hasHChildren
bool hasHChildren() const
Definition Item.h:1466

Arcane::Cell::edge
Edge edge(Int32 i) const
i-th edge of the cell
Definition Item.h:1415

Arcane::Cell::Cell
Cell()=default
Constructor of a null cell.

Arcane::Cell::whichChildAmI
Int32 whichChildAmI(CellLocalId local_id) const
Definition Item.h:1499

Arcane::Cell::faceId
FaceLocalId faceId(Int32 i) const
i-th face of the cell
Definition Item.h:1406

Arcane::Cell::isActive
bool isActive() const
Definition Item.h:1451

Arcane::Cell::level
Int32 level() const
Definition Item.h:1473

Arcane::Cell::hParent
Cell hParent() const
Definition Item.h:1432

Arcane::Cell::edges
EdgeConnectedListViewType edges() const
List of edges of the cell.
Definition Item.h:1421

Arcane::Cell::nbHParent
Int32 nbHParent() const
Number of parents for AMR.
Definition Item.h:1435

Arcane::Cell::kind
constexpr eItemKind kind() const
Entity kind.
Definition Item.h:1391

Arcane::Cell::LocalIdType
CellLocalId LocalIdType
Type of localId().
Definition Item.h:1348

Arcane::DoF
degree of freedom class.
Definition Item.h:1649

Arcane::DoF::DoF
constexpr DoF(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:1666

Arcane::DoF::DoF
DoF(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the internal entity.
Definition Item.h:1699

Arcane::DoF::DoF
DoF()=default
Constructor for a non-connected cell.

Arcane::DoF::itemLocalId
DoFLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:1722

Arcane::DoF::DoF
constexpr DoF(const Item &aitem)
Constructs a reference to the abase entity.
Definition Item.h:1692

Arcane::DoF::operator=
DoF & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:1706

Arcane::DoF::DoF
DoF(ItemInternal *ainternal)
(deprecated) Constructs a reference to the internal entity
Definition Item.h:1678

Arcane::DoF::DoF
constexpr DoF(const ItemBase &abase)
Constructs a reference to the abase entity.
Definition Item.h:1685

Arcane::DoF::kind
constexpr eItemKind kind() const
Entity kind.
Definition Item.h:1719

Arcane::Edge
Edge of a cell.
Definition Item.h:875

Arcane::Edge::faces
FaceConnectedListViewType faces() const
List of faces of the edge.
Definition Item.h:996

Arcane::Edge::kind
constexpr eItemKind kind() const
Kind of the entity.
Definition Item.h:966

Arcane::Edge::cells
CellConnectedListViewType cells() const
List of edge cells.
Definition Item.h:984

Arcane::Edge::cell
Cell cell(Int32 i) const
i-th cell of the edge
Definition Item.h:1759

Arcane::Edge::face
Face face(Int32 i) const
i-th face of the edge
Definition Item.h:1753

Arcane::Edge::Edge
Edge(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the entity internal.
Definition Item.h:950

Arcane::Edge::Edge
constexpr Edge(const Item &aitem)
Constructs a reference to the entity aitem.
Definition Item.h:943

Arcane::Edge::faceIds
FaceLocalIdView faceIds() const
List of faces of the edge.
Definition Item.h:1002

Arcane::Edge::operator=
Edge & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:957

Arcane::Edge::nbFace
Int32 nbFace() const
Number of faces connected to the edge.
Definition Item.h:975

Arcane::Edge::cellIds
CellLocalIdView cellIds() const
List of edge cells.
Definition Item.h:990

Arcane::Edge::Edge
constexpr Edge(const ItemBase &abase)
Constructs a reference to the entity abase.
Definition Item.h:936

Arcane::Edge::Edge
Edge()=default
Creates a null edge.

Arcane::Edge::faceId
FaceLocalId faceId(Int32 i) const
i-th face of the edge
Definition Item.h:999

Arcane::Edge::Edge
Edge(ItemInternal *ainternal)
(deprecated) Constructs a reference to the entity internal
Definition Item.h:929

Arcane::Edge::LocalIdType
EdgeLocalId LocalIdType
Type of localId().
Definition Item.h:923

Arcane::Edge::Edge
Edge(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:916

Arcane::Edge::nbNode
Int32 nbNode() const
Number of vertices of the edge.
Definition Item.h:972

Arcane::Edge::cellId
CellLocalId cellId(Int32 i) const
i-th edge cell
Definition Item.h:987

Arcane::Edge::nbCell
Int32 nbCell() const
Number of cells connected to the edge.
Definition Item.h:978

Arcane::Edge::itemLocalId
EdgeLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:969

Arcane::Face
Face of a cell.
Definition Item.h:1032

Arcane::Face::Face
Face()=default
Creation of a face not connected to the mesh.

Arcane::Face::isMasterFace
bool isMasterFace() const
true if it is the master face of an interface
Definition Item.h:1216

Arcane::Face::kind
constexpr eItemKind kind() const
Entity kind.
Definition Item.h:1123

Arcane::Face::LocalIdType
FaceLocalId LocalIdType
Type of localId().
Definition Item.h:1080

Arcane::Face::frontCellId
CellLocalId frontCellId() const
Cell in front of the face (null cell if none).
Definition Item.h:1185

Arcane::Face::frontCell
Cell frontCell() const
Cell in front of the face (null cell if none).
Definition Item.h:1780

Arcane::Face::cellId
CellLocalId cellId(Int32 i) const
i-th cell of the face
Definition Item.h:1138

Arcane::Face::edgeIds
EdgeLocalIdView edgeIds() const
List of edges of the face.
Definition Item.h:1252

Arcane::Face::cell
Cell cell(Int32 i) const
i-th cell of the face
Definition Item.h:1793

Arcane::Face::nbCell
Int32 nbCell() const
Number of cells of the face (1 or 2).
Definition Item.h:1129

Arcane::Face::isBoundary
ARCANE_DEPRECATED_118 bool isBoundary() const
Definition Item.h:1154

Arcane::Face::slaveFaces
FaceConnectedListViewType slaveFaces() const
List of slave faces associated with this master face.
Definition Item.h:1230

Arcane::Face::Face
constexpr Face(const Item &aitem)
Constructs a reference to the item entity.
Definition Item.h:1100

Arcane::Face::isBoundaryOutside
ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
Indicates if the face is on the subdomain boundary facing outwards.
Definition Item.h:1167

Arcane::Face::edges
EdgeConnectedListViewType edges() const
List of edges of the face.
Definition Item.h:1246

Arcane::Face::isSubDomainBoundary
bool isSubDomainBoundary() const
Indicates if the face is on the subdomain boundary (i.e nbCell()==1).
Definition Item.h:1148

Arcane::Face::itemLocalId
FaceLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:1126

Arcane::Face::edgeId
EdgeLocalId edgeId(Int32 i) const
i-th edge of the face
Definition Item.h:1249

Arcane::Face::cells
CellConnectedListViewType cells() const
List of cells of the face.
Definition Item.h:1135

Arcane::Face::masterFace
Face masterFace() const
Master face associated with this face.
Definition Item.h:1213

Arcane::Face::isSlaveFace
bool isSlaveFace() const
true if it is a slave face of an interface
Definition Item.h:1219

Arcane::Face::edge
Edge edge(Int32 i) const
i-th edge of the face
Definition Item.h:1243

Arcane::Face::Face
constexpr Face(const ItemBase &abase)
Constructs a reference to the base entity.
Definition Item.h:1093

Arcane::Face::backCellId
CellLocalId backCellId() const
Cell behind the face (null cell if none).
Definition Item.h:1179

Arcane::Face::Face
Face(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the internal entity.
Definition Item.h:1107

Arcane::Face::isSubDomainBoundaryOutside
bool isSubDomainBoundaryOutside() const
Indicates if the face is on the subdomain boundary facing outwards.
Definition Item.h:1157

Arcane::Face::Face
Face(ItemInternal *ainternal)
(deprecated) Constructs a reference to the internal entity
Definition Item.h:1086

Arcane::Face::boundaryCell
Cell boundaryCell() const
Cell associated with this boundary face (null cell if none).
Definition Item.h:1768

Arcane::Face::nbEdge
Int32 nbEdge() const
Number of edges of the face.
Definition Item.h:1240

Arcane::Face::isTiedFace
bool isTiedFace() const
true if it is a slave or master face of an interface
Definition Item.h:1222

Arcane::Face::cellIds
CellLocalIdView cellIds() const
List of cells of the face.
Definition Item.h:1141

Arcane::Face::operator=
Face & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:1114

Arcane::Face::backCell
Cell backCell() const
Cell behind the face (null cell if none).
Definition Item.h:1774

Arcane::Face::Face
constexpr Face(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:1073

Arcane::Face::oppositeCell
Cell oppositeCell(Cell cell) const
Opposite cell of this face to the cell cell.
Definition Item.h:1786

Arcane::Face::oppositeCellId
CellLocalId oppositeCellId(CellLocalId cell_id) const
Opposite cell of this face to the cell cell.
Definition Item.h:1199

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

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

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

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

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

Arcane::ItemConnectedEnumeratorBaseT
Typed base class for enumerators over a list of connected entities.
Definition ItemConnectedEnumeratorBase.h:113

Arcane::ItemConnectedListViewConstIteratorT
Definition ItemConnectedListView.h:154

Arcane::ItemConnectedListViewT
View of a list of entities connected to another.
Definition ItemConnectedListView.h:348

Arcane::ItemEnumeratorBaseT
Base class for enumerators over a list of entities.
Definition ItemEnumeratorBase.h:201

Arcane::ItemFlags::II_Shared
@ II_Shared
The entity is shared by another subdomain.
Definition ItemFlags.h:59

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_Boundary
@ II_Boundary
The entity is on the boundary.
Definition ItemFlags.h:51

Arcane::ItemInfoListViewT
Base class for specialized views of entity information.
Definition ItemInfoListView.h:102

Arcane::ItemInfoListViewT::operator[]
ItemType operator[](ItemLocalId local_id) const
Entity associated with local ID local_id.
Definition Item.h:1887

Arcane::ItemInfoListView::operator[]
Item operator[](ItemLocalId local_id) const
Entity associated with local ID local_id.
Definition Item.h:1869

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

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

Arcane::ItemLocalIdToItemConverterT
Class to convert an ItemLocalId to an entity (Item).
Definition ItemLocalId.h:176

Arcane::ItemLocalIdToItemConverterT::operator[]
constexpr __host__ __device__ ItemType operator[](ItemLocalIdType local_id) const
Entity of local ID local_id.
Definition Item.h:1924

Arcane::ItemLocalIdToItemConverter::operator[]
constexpr __host__ __device__ Item operator[](ItemLocalId local_id) const
Entity of local ID local_id.
Definition Item.h:1905

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::ItemSharedInfo::m_items_internal
ConstArrayView< ItemInternal * > m_items_internal
ItemInternal of entities.
Definition ItemSharedInfo.h:281

Arcane::LocalIdType

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::ItemVectorT
Typed entity vector.
Definition ItemVector.h:168

Arcane::ItemVectorViewConstIteratorT
Definition ItemVectorView.h:161

Arcane::ItemVectorViewT
View on a typed array of entities.
Definition ItemVectorView.h:420

Arcane::ItemWithNodes
Mesh element based on nodes (Edge,Face,Cell).
Definition Item.h:773

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the entity internal.
Definition Item.h:821

Arcane::ItemWithNodes::nodeId
NodeLocalId nodeId(Int32 index) const
i-th node of the entity.
Definition Item.h:849

Arcane::ItemWithNodes::ItemWithNodes
constexpr ItemWithNodes(const Item &aitem)
Constructs a reference to the entity aitem.
Definition Item.h:814

Arcane::ItemWithNodes::node
Node node(Int32 i) const
i-th node of the entity
Definition Item.h:840

Arcane::ItemWithNodes::ItemWithNodes
constexpr ItemWithNodes(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:790

Arcane::ItemWithNodes::nbLinearNode
Int32 nbLinearNode() const
Number of nodes of the associated linear entity (if entity order 2 or more).
Definition Item.h:852

Arcane::ItemWithNodes::nodes
NodeConnectedListViewType nodes() const
List of nodes of the entity.
Definition Item.h:843

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(ItemInternal *ainternal)
(deprecated) Constructs a reference to the entity internal
Definition Item.h:800

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes()=default
Creation of an entity not connected to the mesh.

Arcane::ItemWithNodes::nbNode
Int32 nbNode() const
Number of nodes of the entity.
Definition Item.h:837

Arcane::ItemWithNodes::ItemWithNodes
constexpr ItemWithNodes(const ItemBase &abase)
Constructs a reference to the entity abase.
Definition Item.h:807

Arcane::ItemWithNodes::nodeIds
NodeLocalIdView nodeIds() const
List of nodes of the entity.
Definition Item.h:846

Arcane::ItemWithNodes::operator=
ItemWithNodes & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:828

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

Arcane::Item
Base class for a mesh element.
Definition Item.h:84

Arcane::Item::nbParent
Int32 nbParent() const
Number of parents for submeshes.
Definition Item.h:297

Arcane::Item::isDoF
constexpr bool isDoF() const
true if the entity is of the DoF kind
Definition Item.h:345

Arcane::Item::typeInfo
const ItemTypeInfo * typeInfo() const
Information about the entity type.
Definition Item.h:406

Arcane::Item::mutableItemBase
impl::MutableItemBase mutableItemBase() const
Mutable internal part of the entity.
Definition Item.h:394

Arcane::Item::_nbHParent
Int32 _nbHParent() const
Number of parents for AMR.
Definition Item.h:461

Arcane::Item::NULL_ELEMENT
static const Int32 NULL_ELEMENT
Null element index.
Definition Item.h:175

Arcane::Item::flags
constexpr Int32 flags() const
Entity flags.
Definition Item.h:355

Arcane::Item::Item
Item(ItemInternal *ainternal)
Constructs a reference to the internal entity.
Definition Item.h:196

Arcane::Item::internal
ItemInternal * internal() const
Internal part of the entity.
Definition Item.h:368

Arcane::Item::localId
constexpr Int32 localId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:233

Arcane::Item::toEdge
Edge toEdge() const
Converts the entity to the Edge kind.
Definition Item.h:1816

Arcane::Item::Item
Item(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the internal entity.
Definition Item.h:214

Arcane::Item::_nbCell
constexpr Integer _nbCell() const
Number of cells connected to the entity (for nodes, edges and faces).
Definition Item.h:459

Arcane::Item::Item
Item()=default
Creation of a null mesh entity.

Arcane::Item::isFace
constexpr bool isFace() const
true if the entity is of the Face kind.
Definition Item.h:333

Arcane::Item::typeName
static String typeName(Int32 type)
Cell type name cell_type.
Definition Item.cc:54

Arcane::Item::owner
Int32 owner() const
Owner subdomain number of the entity.
Definition Item.h:252

Arcane::Item::m_shared_info
ItemSharedInfo * m_shared_info
Shared information among all entities with the same characteristics.
Definition Item.h:419

Arcane::Item::LocalIdType
ItemLocalId LocalIdType
Type of localId().
Definition Item.h:109

Arcane::Item::isParticle
constexpr bool isParticle() const
true if the entity is of the Particle kind.
Definition Item.h:339

Arcane::Item::toItemWithNodes
ItemWithNodes toItemWithNodes() const
Converts the entity to the ItemWithNodes kind.
Definition Item.h:1802

Arcane::Item::toDoF
DoF toDoF() const
Converts the entity to the DoF kind.
Definition Item.h:1844

Arcane::Item::toCell
Cell toCell() const
Converts the entity to the Cell kind.
Definition Item.h:1830

Arcane::Item::Tri3
@ Tri3
Triangle type element (3 vertices, 2D).
Definition Item.h:161

Arcane::Item::Quad4
@ Quad4
Quad type element (4 vertices, 2D).
Definition Item.h:162

Arcane::Item::Pentagon5
@ Pentagon5
Pentagon type element (5 vertices, 2D).
Definition Item.h:163

Arcane::Item::Unknown
@ Unknown
Null type element.
Definition Item.h:158

Arcane::Item::Pyramid
@ Pyramid
Pyramid type element (5 vertices, 3D).
Definition Item.h:166

Arcane::Item::Bar2
@ Bar2
Edge type element (2 vertices, 1D, 2D and 3D).
Definition Item.h:160

Arcane::Item::Vertex
@ Vertex
Node type element (1 vertex 1D, 2D and 3D).
Definition Item.h:159

Arcane::Item::Hexa
@ Hexa
Hexahedron type element (8 vertices, 3D).
Definition Item.h:168

Arcane::Item::Hexagon6
@ Hexagon6
Hexagon type element (6 vertices, 2D).
Definition Item.h:164

Arcane::Item::Penta
@ Penta
Pentahedron type element (6 vertices, 3D).
Definition Item.h:167

Arcane::Item::Wedge8
@ Wedge8
Prism type element with 8 faces (hexagonal base).
Definition Item.h:170

Arcane::Item::Wedge7
@ Wedge7
Prism type element with 7 faces (pentagonal base).
Definition Item.h:169

Arcane::Item::Tetra
@ Tetra
Tetrahedron type element (4 vertices, 3D).
Definition Item.h:165

Arcane::Item::_nbFace
constexpr Integer _nbFace() const
Number of faces of the entity or number of faces connected to the entity (for nodes and edges).
Definition Item.h:457

Arcane::Item::itemFamily
IItemFamily * itemFamily() const
Family from which the entity originates.
Definition Item.h:261

Arcane::Item::_nbEdge
constexpr Integer _nbEdge() const
Number of edges of the entity or number of edges connected to the entity (for nodes).
Definition Item.h:455

Arcane::Item::toParticle
Particle toParticle() const
Converts the entity to the Particle kind.
Definition Item.h:1837

Arcane::Item::hasFlags
constexpr bool hasFlags(Int32 flags) const
Returns if the flags are set for the entity.
Definition Item.h:352

Arcane::Item::Item
constexpr __host__ __device__ Item(const ItemBase &abase)
Constructs a reference to the abase entity.
Definition Item.h:207

Arcane::Item::isNode
constexpr bool isNode() const
true if the entity is of the Node kind.
Definition Item.h:315

Arcane::Item::uniqueId
ItemUniqueId uniqueId() const
Unique identifier across all domains.
Definition Item.h:239

Arcane::Item::Item
constexpr __host__ __device__ Item(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:184

Arcane::Item::null
constexpr bool null() const
true if the entity is null (i.e. not connected to the mesh)
Definition Item.h:230

Arcane::Item::isItemWithNodes
constexpr bool isItemWithNodes() const
true if the entity is of the ItemWithNodes kind.
Definition Item.h:308

Arcane::Item::_nbNode
constexpr Integer _nbNode() const
Number of nodes of the entity.
Definition Item.h:453

Arcane::Item::itemLocalId
constexpr ItemLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:236

Arcane::Item::toFace
Face toFace() const
Converts the entity to the Face kind.
Definition Item.h:1823

Arcane::Item::isOwn
constexpr bool isOwn() const
true if the entity belongs to the subdomain
Definition Item.h:267

Arcane::Item::_nbParent
Integer _nbParent() const
Number of parents for submeshes.
Definition Item.h:465

Arcane::Item::isCell
constexpr bool isCell() const
true if the entity is of the Cell kind.
Definition Item.h:321

Arcane::Item::parent
Item parent(Int32 i) const
i-th parent for submeshes
Definition Item.h:300

Arcane::Item::itemTypeId
ItemTypeId itemTypeId() const
Entity type.
Definition Item.h:258

Arcane::Item::parent
Item parent() const
first parent for submeshes
Definition Item.h:303

Arcane::Item::m_local_id
Int32 m_local_id
Local number (in the subdomain) of the entity.
Definition Item.h:429

Arcane::Item::isEdge
constexpr bool isEdge() const
true if the entity is of the Edge kind.
Definition Item.h:327

Arcane::Item::itemBase
impl::ItemBase itemBase() const
Internal part of the entity.
Definition Item.h:383

Arcane::Item::isShared
bool isShared() const
True if the entity is shared by other subdomains.
Definition Item.h:279

Arcane::Item::kind
constexpr eItemKind kind() const
Entity kind.
Definition Item.h:264

Arcane::Item::_nbHChildren
Int32 _nbHChildren() const
Number of children for AMR.
Definition Item.h:463

Arcane::Item::_flags
constexpr Int32 _flags() const
Entity flags.
Definition Item.h:451

Arcane::Item::type
Int16 type() const
Entity type.
Definition Item.h:255

Arcane::Item::_nbLinearNode
Int32 _nbLinearNode() const
Number of nodes of the entity.
Definition Item.h:491

Arcane::Item::operator=
Item & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:221

Arcane::Item::toNode
Node toNode() const
Converts the entity to the Node kind.
Definition Item.h:1809

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

Arcane::Node::itemLocalId
constexpr NodeLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:692

Arcane::Node::cell
Cell cell(Int32 i) const
i-th cell of the node
Definition Item.h:1744

Arcane::Node::kind
constexpr eItemKind kind() const
Kind of the entity.
Definition Item.h:689

Arcane::Node::faceIds
FaceLocalIdView faceIds() const
List of faces of the node.
Definition Item.h:734

Arcane::Node::Node
Node(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the entity internal.
Definition Item.h:673

Arcane::Node::cells
CellConnectedListViewType cells() const
List of cells of the node.
Definition Item.h:728

Arcane::Node::_internalActiveCells
CellVectorView _internalActiveCells(Int32Array &local_ids) const
Enumerates the cells connected to the node.
Definition Item.h:742

Arcane::Node::nbFace
constexpr Int32 nbFace() const
Number of faces connected to the node.
Definition Item.h:698

Arcane::Node::Node
Node(ItemInternal *ainternal)
(deprecated) Constructs a reference to the entity internal
Definition Item.h:652

Arcane::Node::edgeIds
EdgeLocalIdView edgeIds() const
List of edges of the node.
Definition Item.h:731

Arcane::Node::faceId
FaceLocalId faceId(Int32 i) const
i-th face of the node
Definition Item.h:716

Arcane::Node::nbEdge
constexpr Int32 nbEdge() const
Number of edges connected to the node.
Definition Item.h:695

Arcane::Node::faces
FaceConnectedListViewType faces() const
List of faces of the node.
Definition Item.h:725

Arcane::Node::Node
constexpr Node(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:639

Arcane::Node::operator=
Node & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:680

Arcane::Node::face
Face face(Int32 i) const
i-th face of the node
Definition Item.h:1738

Arcane::Node::Node
constexpr Node(const Item &aitem)
Constructs a reference to the entity abase.
Definition Item.h:666

Arcane::Node::cellIds
CellLocalIdView cellIds() const
List of cells of the node.
Definition Item.h:737

Arcane::Node::Node
constexpr Node(const ItemBase &abase)
Constructs a reference to the entity abase.
Definition Item.h:659

Arcane::Node::edge
Edge edge(Int32 i) const
i-th edge of the node
Definition Item.h:1732

Arcane::Node::nbCell
Int32 nbCell() const
Number of cells connected to the node.
Definition Item.h:701

Arcane::Node::edges
EdgeConnectedListViewType edges() const
List of edges of the node.
Definition Item.h:722

Arcane::Node::cellId
CellLocalId cellId(Int32 i) const
i-th cell of the node
Definition Item.h:719

Arcane::Node::edgeId
EdgeLocalId edgeId(Int32 i) const
i-th edge of the node
Definition Item.h:713

Arcane::Node::LocalIdType
NodeLocalId LocalIdType
Type of localId().
Definition Item.h:646

Arcane::Particle
Particle.
Definition Item.h:1529

Arcane::Particle::Particle
Particle()=default
Constructor for a null particle.

Arcane::Particle::hasCell
bool hasCell() const
True if the particle is in a mesh cell.
Definition Item.h:1612

Arcane::Particle::Particle
Particle(Int32 local_id, ItemSharedInfo *shared_info)
Constructor reserved for enumerators.
Definition Item.h:1546

Arcane::Particle::itemLocalId
ParticleLocalId itemLocalId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:1599

Arcane::Particle::kind
constexpr eItemKind kind() const
Entity kind.
Definition Item.h:1596

Arcane::Particle::cell
Cell cell() const
Cell to which the particle belongs. You must call setCell() before calling this function....
Definition Item.h:1606

Arcane::Particle::cellId
CellLocalId cellId() const
Cell connected to the particle.
Definition Item.h:1609

Arcane::Particle::Particle
Particle(const ItemInternalPtr *internals, Int32 local_id)
Constructs a reference to the internal entity.
Definition Item.h:1580

Arcane::Particle::Particle
constexpr Particle(const ItemBase &abase)
Constructs a reference to the abase entity.
Definition Item.h:1566

Arcane::Particle::cellOrNull
Cell cellOrNull() const
Cell to which the particle belongs or null cell. Returns cell() if the particle is in a cell or the n...
Definition Item.h:1619

Arcane::Particle::operator=
Particle & operator=(ItemInternal *ainternal)
Copy operator.
Definition Item.h:1587

Arcane::Particle::LocalIdType
ParticleLocalId LocalIdType
Type of localId().
Definition Item.h:1553

Arcane::Particle::Particle
constexpr Particle(const Item &aitem)
Constructs a reference to the aitem entity.
Definition Item.h:1573

Arcane::Particle::Particle
Particle(ItemInternal *ainternal)
(deprecated) Constructs a reference to the internal entity
Definition Item.h:1559

Arcane::SimdItemT
Manages a vector of ItemType entities.
Definition SimdItem.h:272

Arcane::String
Unicode character string.
Definition arccore/src/base/arccore/base/String.h:70

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

Arcane::CellVectorView
ItemVectorViewT< Cell > CellVectorView
View over a vector of cells.
Definition ItemTypes.h:305

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
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37

Arcane::NodeConnectedListViewType
NodeConnectedListView NodeConnectedListViewType
List of connected nodes.
Definition ItemTypes.h:350

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

Arcane::CellConnectedListViewType
CellConnectedListView CellConnectedListViewType
List of connected cells.
Definition ItemTypes.h:356

Arcane::operator<
bool operator<(const Item &item1, const Item &item2)
Compare two entities.
Definition Item.h:566

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

Arcane::IK_Particle
@ IK_Particle
Particle mesh entity.
Definition ArcaneTypes.h:231

Arcane::IK_Node
@ IK_Node
Node mesh entity.
Definition ArcaneTypes.h:226

Arcane::IK_Cell
@ IK_Cell
Cell mesh entity.
Definition ArcaneTypes.h:229

Arcane::IK_Unknown
@ IK_Unknown
Unknown or uninitialized mesh entity.
Definition ArcaneTypes.h:232

Arcane::IK_Face
@ IK_Face
Face mesh entity.
Definition ArcaneTypes.h:228

Arcane::IK_DoF
@ IK_DoF
Degree of Freedom mesh entity.
Definition ArcaneTypes.h:230

Arcane::IK_Edge
@ IK_Edge
Edge mesh entity.
Definition ArcaneTypes.h:227

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::EdgeConnectedListViewType
EdgeConnectedListView EdgeConnectedListViewType
List of connected edges.
Definition ItemTypes.h:352

Arcane::FaceConnectedListViewType
FaceConnectedListView FaceConnectedListViewType
List of connected faces.
Definition ItemTypes.h:354

Arcane::eMeshAMRKind::Cell
@ Cell
The mesh is AMR by cell.
Definition MeshKind.h:53

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