d1/dd4/Item_8h_source.html

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

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

// Copyright 2000-2025 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 */

/*                                                                           */

/* Informations sur les éléments du maillage.                                */

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

#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 pour vérifier en mode Check que les conversions entre les

// les genres d'entités sont correctes.

#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

{

  // Pour accéder aux constructeurs privés

  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;


  // Pour accéder à _internal()

  friend class ItemCompatibility;


 public:


  typedef ItemInternal* ItemInternalPtr;


  typedef ItemLocalId LocalIdType;


  using ItemBase = impl::ItemBase;


 public:


   */


  class Index

  {


    // TODO Rendre obsolète lorsqu'on aura supprimer

    // les classes dérivées qui sont obsolètes.

    // On ne peut pas le faire avant car cela génère trop

    // d'avertissements de compilation.

   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

    // Réduit au minimum pour compatibilité.

  };


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

  constexpr ARCCORE_HOST_DEVICE Item(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  //! Création d'une entité de maillage nulle

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

  }

  Item(ItemInternal* ainternal) {…}


  // NOTE: Pour le constructeur suivant; il est indispensable d'utiliser

  // const& pour éviter une ambiguité avec le constructeur par recopie


  constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase)

  : m_shared_info(abase.m_shared_info)

  , m_local_id(abase.m_local_id)

  {

  }

  constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase) {…}


  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(const ItemInternalPtr* internals,Int32 local_id) {…}


  Item& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Item& operator=(ItemInternal* ainternal) {…}


 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

    // Ne pas utiliser l'accesseur normal car ce tableau peut etre utilise pour la maille

    // nulle et dans ce cas m_local_id vaut NULL_ITEM_LOCAL_ID (qui est negatif)

    // ce qui provoque une exception pour debordement de tableau.

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

  }

  ItemUniqueId uniqueId() const {…}


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


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


  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:


  bool isItemWithNodes() const

  {

    eItemKind ik = kind();

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

  }

  bool isItemWithNodes() const {…}


  bool isNode() const

  {

    eItemKind ik = kind();

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

  }

  bool isNode() const {…}


  bool isCell() const

  {

    eItemKind ik = kind();

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

  }

  bool isCell() const {…}


  bool isEdge() const

  {

    eItemKind ik = kind();

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

  }

  bool isEdge() const {…}


  bool isFace() const

  {

    eItemKind ik = kind();

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

  }

  bool isFace() const {…}


  bool isParticle() const

  {

    eItemKind ik = kind();

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

  }

  bool isParticle() const {…}


  bool isDoF() const

  {

    eItemKind ik = kind();

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

  }

  bool isDoF() const {…}


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

  }

  ItemInternal* internal() const {…}


 public:


  impl::ItemBase itemBase() const

  {

    return impl::ItemBase(m_local_id,m_shared_info);

  }

  impl::ItemBase itemBase() const {…}


  impl::MutableItemBase mutableItemBase() const

  {

    return impl::MutableItemBase(m_local_id,m_shared_info);

  }

  impl::MutableItemBase mutableItemBase() const {…}


  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:


  void _checkKind(bool is_valid) const

  {

    if (!is_valid)

      _badConversion();

  }

  void _badConversion() const;

  void _set(ItemInternal* ainternal)

  {

    _setFromInternal(ainternal);

  }

  void _set(const Item& rhs)

  {

    _setFromItem(rhs);

  }


 protected:


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

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

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

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

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


  inline Node _node(Int32 index) const;

  inline Edge _edge(Int32 index) const;

  inline Face _face(Int32 index) const;

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


 private:


  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;

  }

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

}

operator==(const Item& item1,const Item& item2) {…}


inline bool


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

{

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

}

operator!=(const Item& item1,const Item& item2) {…}


inline bool

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

{

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

}

inline bool {…}


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

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


} // End namespace Arcane


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

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


#include "arcane/ItemVectorView.h"

#include "arcane/ItemConnectedListView.h"


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

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


namespace Arcane

{


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

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


class ARCANE_CORE_EXPORT Node

: public Item

{

  using ThatClass = Node;

  // 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>;


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

  };

  class ARCANE_DEPRECATED_REASON("Y2024: Use NodeLocalId instead") Index {…};


 protected:


  Node(Int32 local_id,ItemSharedInfo* shared_info)

  : Item(local_id,shared_info) {}

  Node(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  typedef NodeLocalId LocalIdType;


  Node() = default;


  Node(ItemInternal* ainternal) : Item(ainternal)

  { ARCANE_CHECK_KIND(isNode); }

  Node(ItemInternal* ainternal) : Item(ainternal) {…}


  Node(const ItemBase& abase) : Item(abase)

  { ARCANE_CHECK_KIND(isNode); }

  Node(const ItemBase& abase) : Item(abase) {…}


  explicit Node(const Item& aitem) : Item(aitem)

  { ARCANE_CHECK_KIND(isNode); }

  explicit Node(const Item& aitem) : Item(aitem) {…}


  Node(const ItemInternalPtr* internals,Int32 local_id) : Item(internals,local_id)

  { ARCANE_CHECK_KIND(isNode); }

  Node(const ItemInternalPtr* internals,Int32 local_id) : Item(internals,local_id) {…}


  Node& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Node& operator=(ItemInternal* ainternal) {…}


 public:


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


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


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

  }

  CellVectorView _internalActiveCells(Int32Array& local_ids) const {…}


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

};

class ARCANE_CORE_EXPORT Node {…};


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

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


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;

  // 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>;


 protected:


  ItemWithNodes(Int32 local_id,ItemSharedInfo* shared_info)

  : Item(local_id,shared_info) {}

  ItemWithNodes(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  ItemWithNodes() = default;


  ItemWithNodes(ItemInternal* ainternal) : Item(ainternal)

  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes(ItemInternal* ainternal) : Item(ainternal) {…}


  ItemWithNodes(const ItemBase& abase) : Item(abase)

  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes(const ItemBase& abase) : Item(abase) {…}


  explicit ItemWithNodes(const Item& aitem) : Item(aitem)

  { ARCANE_CHECK_KIND(isItemWithNodes); }

  explicit ItemWithNodes(const Item& aitem) : Item(aitem) {…}


  ItemWithNodes(const ItemInternalPtr* internals,Int32 local_id)

  : Item(internals,local_id)

  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes(const ItemInternalPtr* internals,Int32 local_id) {…}


  ItemWithNodes& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  ItemWithNodes& operator=(ItemInternal* ainternal) {…}


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


  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 ItemWithNodes {…};


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

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


class ARCANE_CORE_EXPORT Edge

: public ItemWithNodes

{

  using ThatClass = Edge;

  // 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>;


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

  };

  class ARCANE_DEPRECATED_REASON("Y2024: Use EdgeLocalId instead") Index {…};


  private:


  Edge(Int32 local_id,ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id,shared_info) {}

  Edge(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  typedef EdgeLocalId LocalIdType;


  Edge() = default;


  Edge(ItemInternal* ainternal) : ItemWithNodes(ainternal)

  { ARCANE_CHECK_KIND(isEdge); }

  Edge(ItemInternal* ainternal) : ItemWithNodes(ainternal) {…}


  Edge(const ItemBase& abase) : ItemWithNodes(abase)

  { ARCANE_CHECK_KIND(isEdge); }

  Edge(const ItemBase& abase) : ItemWithNodes(abase) {…}


  explicit Edge(const Item& aitem) : ItemWithNodes(aitem)

  { ARCANE_CHECK_KIND(isEdge); }

  explicit Edge(const Item& aitem) : ItemWithNodes(aitem) {…}


  Edge(const ItemInternalPtr* internals,Int32 local_id)

  : ItemWithNodes(internals,local_id)

  { ARCANE_CHECK_KIND(isEdge); }

  Edge(const ItemInternalPtr* internals,Int32 local_id) {…}


  Edge& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Edge& operator=(ItemInternal* ainternal) {…}


 public:


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

};

class ARCANE_CORE_EXPORT Edge {…};


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

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


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;

  // 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>;


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

  };

  class ARCANE_DEPRECATED_REASON("Y2024: Use FaceLocalId instead") Index {…};


 private:


  Face(Int32 local_id,ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id,shared_info) {}

  Face(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  typedef FaceLocalId LocalIdType;


  Face() = default;


  Face(ItemInternal* ainternal) : ItemWithNodes(ainternal)

  { ARCANE_CHECK_KIND(isFace); }

  Face(ItemInternal* ainternal) : ItemWithNodes(ainternal) {…}


  Face(const ItemBase& abase) : ItemWithNodes(abase)

  { ARCANE_CHECK_KIND(isFace); }

  Face(const ItemBase& abase) : ItemWithNodes(abase) {…}


  explicit Face(const Item& aitem) : ItemWithNodes(aitem)

  { ARCANE_CHECK_KIND(isFace); }

  explicit Face(const Item& aitem) : ItemWithNodes(aitem) {…}


  Face(const ItemInternalPtr* internals,Int32 local_id)

  : ItemWithNodes(internals,local_id)

  { ARCANE_CHECK_KIND(isFace); }

  Face(const ItemInternalPtr* internals,Int32 local_id) {…}


  Face& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Face& operator=(ItemInternal* ainternal) {…}


 public:


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

  }

  bool isSubDomainBoundaryOutside() const {…}


  ARCANE_DEPRECATED_118 bool isBoundaryOutside() const

  {

    return isSubDomainBoundaryOutside();

  }

  ARCANE_DEPRECATED_118 bool isBoundaryOutside() const {…}


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

  }

  CellLocalId oppositeCellId(CellLocalId cell_id) const {…}


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

  }

  FaceConnectedListViewType slaveFaces() const {…}


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

};

class ARCANE_CORE_EXPORT Face {…};


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

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


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;

  // 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>;


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

  };

  class ARCANE_DEPRECATED_REASON("Y2024: Use CellLocalId instead") Index {…};


 private:


  Cell(Int32 local_id,ItemSharedInfo* shared_info)

  : ItemWithNodes(local_id,shared_info) {}

  Cell(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  typedef CellLocalId LocalIdType;


  Cell() = default;


  Cell(ItemInternal* ainternal) : ItemWithNodes(ainternal)

  { ARCANE_CHECK_KIND(isCell); }

  Cell(ItemInternal* ainternal) : ItemWithNodes(ainternal) {…}


  Cell(const ItemBase& abase) : ItemWithNodes(abase)

  { ARCANE_CHECK_KIND(isCell); }

  Cell(const ItemBase& abase) : ItemWithNodes(abase) {…}


  explicit Cell(const Item& aitem) : ItemWithNodes(aitem)

  { ARCANE_CHECK_KIND(isCell); }

  explicit Cell(const Item& aitem) : ItemWithNodes(aitem) {…}


  Cell(const ItemInternalPtr* internals,Int32 local_id)

  : ItemWithNodes(internals,local_id)

  { ARCANE_CHECK_KIND(isCell); }

  Cell(const ItemInternalPtr* internals,Int32 local_id) {…}


  Cell& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Cell& operator=(ItemInternal* ainternal) {…}


 public:


  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 level() const {…}


  Int32 whichChildAmI(const ItemInternal* iitem) const

  {

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

  }

  Int32 whichChildAmI(const ItemInternal* iitem) const {…}


  Int32 whichChildAmI(CellLocalId local_id) const

  {

    return _toItemBase().whichChildAmI(local_id);

  }

  Int32 whichChildAmI(CellLocalId local_id) const {…}


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

};

class ARCANE_CORE_EXPORT Cell {…};


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

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


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

  Particle(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  typedef ParticleLocalId LocalIdType;


  Particle() = default;


  Particle(ItemInternal* ainternal) : Item(ainternal)

  { ARCANE_CHECK_KIND(isParticle); }

  Particle(ItemInternal* ainternal) : Item(ainternal) {…}


  Particle(const ItemBase& abase) : Item(abase)

  { ARCANE_CHECK_KIND(isParticle); }

  Particle(const ItemBase& abase) : Item(abase) {…}


  explicit Particle(const Item& aitem) : Item(aitem)

  { ARCANE_CHECK_KIND(isParticle); }

  explicit Particle(const Item& aitem) : Item(aitem) {…}


  Particle(const ItemInternalPtr* internals,Int32 local_id)

  : Item(internals,local_id)

  { ARCANE_CHECK_KIND(isParticle); }

  Particle(const ItemInternalPtr* internals,Int32 local_id) {…}


  Particle& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  Particle& operator=(ItemInternal* ainternal) {…}


 public:


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

  }

  Cell cellOrNull() const {…}


  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 Particle {…};


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

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


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:


  DoF(Int32 local_id,ItemSharedInfo* shared_info)

  : Item(local_id,shared_info) {}

  DoF(Int32 local_id,ItemSharedInfo* shared_info) {…}


 public:


  using LocalIdType = DoFLocalId;


  DoF() = default;


  DoF(ItemInternal* ainternal) : Item(ainternal)

  { ARCANE_CHECK_KIND(isDoF); }

  DoF(ItemInternal* ainternal) : Item(ainternal) {…}


  DoF(const ItemBase& abase) : Item(abase)

  { ARCANE_CHECK_KIND(isDoF); }

  DoF(const ItemBase& abase) : Item(abase) {…}


  explicit DoF(const Item& aitem) : Item(aitem)

  { ARCANE_CHECK_KIND(isDoF); }

  explicit DoF(const Item& aitem) : Item(aitem) {…}


  DoF(const ItemInternalPtr* internals,Int32 local_id)

  : Item(internals,local_id)

  { ARCANE_CHECK_KIND(isDoF); }

  DoF(const ItemInternalPtr* internals,Int32 local_id) {…}


  DoF& operator=(ItemInternal* ainternal)

  {

    _set(ainternal);

    return (*this);

  }

  DoF& operator=(ItemInternal* ainternal) {…}


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


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

};

class DoF {…};


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

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


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

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


inline Edge Node::

edge(Int32 i) const

{

  return _edge(i);

}

inline Edge Node:: {…}


inline Face Node::

face(Int32 i) const

{

  return _face(i);

}

inline Face Node:: {…}


inline Cell Node::

cell(Int32 i) const

{

  return _cell(i);

}

inline Cell Node:: {…}


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

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


inline Face Edge::

face(Int32 i) const

{

  return _face(i);

}

inline Face Edge:: {…}


inline Cell Edge::

cell(Int32 i) const

{

  return _cell(i);

}

inline Cell Edge:: {…}


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

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


inline Cell Face::

boundaryCell() const

{

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

}

inline Cell Face:: {…}


inline Cell Face::

backCell() const

{

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

}

inline Cell Face:: {…}


inline Cell Face::

frontCell() const

{

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

}

inline Cell Face:: {…}


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:: {…}


inline Cell Face::

cell(Int32 i) const

{

  return _cell(i);

}

inline Cell Face:: {…}


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

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


inline ItemWithNodes Item::

toItemWithNodes() const

{

  ARCANE_CHECK_KIND(isItemWithNodes);

  return ItemWithNodes(*this);

}

inline ItemWithNodes Item:: {…}


inline Node Item::

toNode() const

{

  ARCANE_CHECK_KIND(isNode);

  return Node(*this);

}

inline Node Item:: {…}


inline Edge Item::

toEdge() const

{

  ARCANE_CHECK_KIND(isEdge);

  return Edge(*this);

}

inline Edge Item:: {…}


inline Face Item::

toFace() const

{

  ARCANE_CHECK_KIND(isFace);

  return Face(*this);

}

inline Face Item:: {…}


inline Cell Item::

toCell() const

{

  ARCANE_CHECK_KIND(isCell);

  return Cell(*this);

}

inline Cell Item:: {…}


inline Particle Item::

toParticle() const

{

  ARCANE_CHECK_KIND(isParticle);

  return Particle(*this);

}

inline Particle Item:: {…}


inline DoF Item::

toDoF() const

{

  ARCANE_CHECK_KIND(isDoF);

  return DoF(*this);

}

inline DoF Item:: {…}


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

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


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:: {…}


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

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


inline Item ItemInfoListView::

operator[](Int32 local_id) const

{

  return Item(local_id, m_item_shared_info);

}

inline Item ItemInfoListView:: {…}


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

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


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>:: {…}


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

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


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

operator[](Int32 local_id) const

{

  return ItemType(local_id, m_item_shared_info);

}

template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>:: {…}


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

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


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:: {…}


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

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


inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::

operator[](Int32 local_id) const

{

  return Item(local_id, m_item_shared_info);

}

inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter:: {…}


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

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


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

}

ItemLocalIdToItemConverterT<ItemType_>:: {…}


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

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


template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_


ItemLocalIdToItemConverterT<ItemType_>::

operator[](Int32 local_id) const

{

  return ItemType(local_id, m_item_shared_info);

}

ItemLocalIdToItemConverterT<ItemType_>:: {…}

 {…}


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

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


} // End namespace Arcane


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

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


#include "arcane/ItemCompatibility.h"


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

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


#endif

  //! Création d'une entité de maillage nulle {…}

    // TODO Rendre obsolète lorsqu'on aura supprimer {…}

  class Index {…};

   */ {…}

class ARCANE_CORE_EXPORT Item {…};

ItemTypes.h
Déclarations de types sur les entités.

Arcane::Cell
Maille d'un maillage.
Definition Item.h:1191

Arcane::Cell::topHParent
Cell topHParent() const
parent de niveau 0 pour l'AMR
Definition Item.h:1313

Arcane::Cell::nbEdge
Int32 nbEdge() const
Nombre d'arêtes de la maille.
Definition Item.h:1281

Arcane::Cell::Cell
Cell(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1245

Arcane::Cell::faces
FaceConnectedListViewType faces() const
Liste des faces de la maille.
Definition Item.h:1272

Arcane::Cell::nbHChildren
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition Item.h:1307

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

Arcane::Cell::Cell
Cell(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1225

Arcane::Cell::face
Face face(Int32 i) const
i-ème face de la maille
Definition Item.h:1269

Arcane::Cell::faceIds
FaceLocalIdView faceIds() const
Liste des faces de la maille.
Definition Item.h:1278

Arcane::Cell::Cell
Cell(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1237

Arcane::Cell::nbFace
Int32 nbFace() const
Nombre de faces de la maille.
Definition Item.h:1266

Arcane::Cell::operator=
Cell & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1254

Arcane::Cell::Cell
Cell(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1249

Arcane::Cell::itemLocalId
CellLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1263

Arcane::Cell::edgeIds
EdgeLocalIdView edgeIds() const
Liste des arêtes de la maille.
Definition Item.h:1293

Arcane::Cell::edgeId
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la maille
Definition Item.h:1287

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

Arcane::Cell::hChild
Cell hChild(Int32 i) const
i-ème enfant AMR
Definition Item.h:1310

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

Arcane::Cell::Cell
Cell(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1241

Arcane::Cell::edge
Edge edge(Int32 i) const
i-ème arête de la maille
Definition Item.h:1284

Arcane::Cell::Cell
Cell()=default
Constructeur d'une maille nulle.

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

Arcane::Cell::faceId
FaceLocalId faceId(Int32 i) const
i-ème face de la maille
Definition Item.h:1275

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

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

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

Arcane::Cell::edges
EdgeConnectedListViewType edges() const
Liste des arêtes de la maille.
Definition Item.h:1290

Arcane::Cell::nbHParent
Int32 nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:1304

Arcane::Cell::LocalIdType
CellLocalId LocalIdType
Type du localId()
Definition Item.h:1231

Arcane::DoF
classe degré de liberté.
Definition Item.h:1503

Arcane::DoF::DoF
DoF(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1544

Arcane::DoF::DoF
DoF()=default
Constructeur d'une maille non connectée.

Arcane::DoF::DoF
DoF(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1536

Arcane::DoF::DoF
DoF(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:1540

Arcane::DoF::itemLocalId
DoFLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1562

Arcane::DoF::operator=
DoF & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1549

Arcane::DoF::DoF
DoF(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1532

Arcane::DoF::DoF
DoF(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1520

Arcane::Edge
Arête d'une maille.
Definition Item.h:809

Arcane::Edge::faces
FaceConnectedListViewType faces() const
Liste des faces de l'arête.
Definition Item.h:908

Arcane::Edge::cells
CellConnectedListViewType cells() const
Liste des mailles de l'arête.
Definition Item.h:896

Arcane::Edge::cell
Cell cell(Int32 i) const
i-ème maille de l'arête
Definition Item.h:1599

Arcane::Edge::Edge
Edge(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:859

Arcane::Edge::face
Face face(Int32 i) const
i-ème face de l'arête
Definition Item.h:1593

Arcane::Edge::Edge
Edge(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:867

Arcane::Edge::faceIds
FaceLocalIdView faceIds() const
Liste des faces de l'arête.
Definition Item.h:914

Arcane::Edge::operator=
Edge & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:872

Arcane::Edge::nbFace
Int32 nbFace() const
Nombre de faces connectées à l'arête.
Definition Item.h:887

Arcane::Edge::cellIds
CellLocalIdView cellIds() const
Liste des mailles de l'arête.
Definition Item.h:902

Arcane::Edge::Edge
Edge(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:863

Arcane::Edge::Edge
Edge()=default
Créé une arête nulle.

Arcane::Edge::faceId
FaceLocalId faceId(Int32 i) const
i-ème face de l'arête
Definition Item.h:911

Arcane::Edge::Edge
Edge(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:855

Arcane::Edge::LocalIdType
EdgeLocalId LocalIdType
Type du localId()
Definition Item.h:849

Arcane::Edge::Edge
Edge(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:843

Arcane::Edge::nbNode
Int32 nbNode() const
Nombre de sommets de l'arête.
Definition Item.h:884

Arcane::Edge::cellId
CellLocalId cellId(Int32 i) const
i-ème maille de l'arête
Definition Item.h:899

Arcane::Edge::nbCell
Int32 nbCell() const
Nombre de mailles connectées à l'arête.
Definition Item.h:890

Arcane::Edge::itemLocalId
EdgeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:881

Arcane::Face
Face d'une maille.
Definition Item.h:944

Arcane::Face::Face
Face()=default
Création d'une face non connecté au maillage.

Arcane::Face::isMasterFace
bool isMasterFace() const
true s'il s'agit de la face maître d'une interface
Definition Item.h:1106

Arcane::Face::LocalIdType
FaceLocalId LocalIdType
Type du localId()
Definition Item.h:984

Arcane::Face::frontCellId
CellLocalId frontCellId() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1075

Arcane::Face::Face
Face(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:994

Arcane::Face::frontCell
Cell frontCell() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1620

Arcane::Face::cellId
CellLocalId cellId(Int32 i) const
i-ème maille de la face
Definition Item.h:1028

Arcane::Face::edgeIds
EdgeLocalIdView edgeIds() const
Liste des arêtes de la face.
Definition Item.h:1142

Arcane::Face::cell
Cell cell(Int32 i) const
i-ème maille de la face
Definition Item.h:1633

Arcane::Face::nbCell
Int32 nbCell() const
Nombre de mailles de la face (1 ou 2)
Definition Item.h:1019

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

Arcane::Face::slaveFaces
FaceConnectedListViewType slaveFaces() const
Liste des faces esclaves associées à cette face maître.
Definition Item.h:1120

Arcane::Face::isBoundaryOutside
ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1057

Arcane::Face::edges
EdgeConnectedListViewType edges() const
Liste des arêtes de la face.
Definition Item.h:1136

Arcane::Face::isSubDomainBoundary
bool isSubDomainBoundary() const
Indique si la face est au bord du sous-domaine (i.e nbCell()==1)
Definition Item.h:1038

Arcane::Face::Face
Face(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:998

Arcane::Face::itemLocalId
FaceLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1016

Arcane::Face::edgeId
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la face
Definition Item.h:1139

Arcane::Face::cells
CellConnectedListViewType cells() const
Liste des mailles de la face.
Definition Item.h:1025

Arcane::Face::masterFace
Face masterFace() const
Face maître associée à cette face.
Definition Item.h:1103

Arcane::Face::isSlaveFace
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Definition Item.h:1109

Arcane::Face::edge
Edge edge(Int32 i) const
i-ème arête de la face
Definition Item.h:1133

Arcane::Face::backCellId
CellLocalId backCellId() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1069

Arcane::Face::Face
Face(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1002

Arcane::Face::isSubDomainBoundaryOutside
bool isSubDomainBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1047

Arcane::Face::Face
Face(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:990

Arcane::Face::boundaryCell
Cell boundaryCell() const
Maille associée à cette face frontière (maille nulle si aucune)
Definition Item.h:1608

Arcane::Face::nbEdge
Int32 nbEdge() const
Nombre d'arêtes de la face.
Definition Item.h:1130

Arcane::Face::isTiedFace
bool isTiedFace() const
true s'il s'agit d'une face esclave ou maître d'une interface
Definition Item.h:1112

Arcane::Face::Face
Face(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:978

Arcane::Face::cellIds
CellLocalIdView cellIds() const
Liste des mailles de la face.
Definition Item.h:1031

Arcane::Face::operator=
Face & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1007

Arcane::Face::backCell
Cell backCell() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1614

Arcane::Face::oppositeCell
Cell oppositeCell(Cell cell) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1626

Arcane::Face::oppositeCellId
CellLocalId oppositeCellId(CellLocalId cell_id) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1089

Arcane::IItemFamily
Interface d'une famille d'entités.
Definition IItemFamily.h:84

Arcane::ItemBase
Classe de base pour les entités du maillage.
Definition ItemInternal.h:433

Arcane::ItemBase::m_local_id
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
Definition ItemInternal.h:734

Arcane::ItemBase::m_shared_info
ItemSharedInfo * m_shared_info
Infos partagées entre toutes les entités ayant les mêmes caractéristiques.
Definition ItemInternal.h:740

Arcane::ItemBase::localId
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Definition ItemInternal.h:464

Arcane::ItemConnectedEnumeratorBaseT
Classe de base typeé des énumérateurs sur une liste d'entité connectées.
Definition ItemConnectedEnumeratorBase.h:112

Arcane::ItemConnectedListViewConstIteratorT
Definition ItemConnectedListView.h:153

Arcane::ItemConnectedListViewT
Vue sur une liste d'entités connectées à une autre.
Definition ItemConnectedListView.h:345

Arcane::ItemEnumeratorBaseT
Classe de base des énumérateurs sur une liste d'entité.
Definition ItemEnumeratorBase.h:199

Arcane::ItemFlags::II_Shared
@ II_Shared
L'entité est partagée par un autre sous-domaine.
Definition ItemFlags.h:51

Arcane::ItemFlags::II_HasBackCell
@ II_HasBackCell
L'entité a une maille derrière.
Definition ItemFlags.h:45

Arcane::ItemFlags::II_Own
@ II_Own
L'entité est une entité propre au sous-domaine.
Definition ItemFlags.h:48

Arcane::ItemFlags::II_Boundary
@ II_Boundary
L'entité est sur la frontière.
Definition ItemFlags.h:43

Arcane::ItemInfoListViewT
Classe de base des vues spécialisées des informations sur les entités.
Definition ItemInfoListView.h:100

Arcane::ItemInfoListViewT::operator[]
ItemType operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1727

Arcane::ItemInfoListView::operator[]
Item operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1709

Arcane::ItemInternal
Structure interne d'une entité de maillage.
Definition ItemInternal.h:908

Arcane::ItemLocalIdToItemConverterT
Classe pour convertir un ItemLocalId vers une entité (Item).
Definition ItemLocalId.h:164

Arcane::ItemLocalIdToItemConverterT::operator[]
constexpr __host__ __device__ ItemType operator[](ItemLocalIdType local_id) const
Entité de numéro local local_id.
Definition Item.h:1764

Arcane::ItemLocalIdToItemConverter::operator[]
constexpr __host__ __device__ Item operator[](ItemLocalId local_id) const
Entité de numéro local local_id.
Definition Item.h:1745

Arcane::ItemLocalId
Index d'un Item dans une variable.
Definition ItemLocalId.h:41

Arcane::ItemSharedInfo
Structure interne partagée d'une entité de maillage.
Definition ItemSharedInfo.h:55

Arcane::ItemSharedInfo::m_items_internal
ConstArrayView< ItemInternal * > m_items_internal
ItemInternal des entités.
Definition ItemSharedInfo.h:280

Arcane::LocalIdType

Arcane::ItemTypeId
Type d'une entité (Item).
Definition ItemTypeId.h:32

Arcane::ItemTypeInfo
Infos sur un type d'entité du maillage.
Definition ItemTypeInfo.h:47

Arcane::ItemUniqueId
Identifiant unique d'une entité.
Definition ItemUniqueId.h:35

Arcane::ItemVectorT
Vecteur typé d'entité.
Definition ItemVector.h:166

Arcane::ItemVectorViewConstIteratorT
Definition ItemVectorView.h:160

Arcane::ItemVectorViewT
Vue sur un tableau typé d'entités.
Definition ItemVectorView.h:406

Arcane::ItemWithNodes
Elément de maillage s'appuyant sur des noeuds (Edge,Face,Cell).
Definition Item.h:724

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:762

Arcane::ItemWithNodes::nodeId
NodeLocalId nodeId(Int32 index) const
i-ème noeud de l'entité.
Definition Item.h:788

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:754

Arcane::ItemWithNodes::node
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:779

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:741

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:758

Arcane::ItemWithNodes::nodes
NodeConnectedListViewType nodes() const
Liste des noeuds de l'entité
Definition Item.h:782

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:750

Arcane::ItemWithNodes::ItemWithNodes
ItemWithNodes()=default
Création d'une entité non connectée au maillage.

Arcane::ItemWithNodes::nbNode
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:776

Arcane::ItemWithNodes::nodeIds
NodeLocalIdView nodeIds() const
Liste des noeuds de l'entité
Definition Item.h:785

Arcane::ItemWithNodes::operator=
ItemWithNodes & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:767

Arcane::Item::Index
Index d'un Item dans une variable.
Definition Item.h:119

Arcane::Item
Classe de base d'un élément de maillage.
Definition Item.h:83

Arcane::Item::nbParent
Int32 nbParent() const
Nombre de parents pour les sous-maillages.
Definition Item.h:283

Arcane::Item::typeInfo
const ItemTypeInfo * typeInfo() const
Infos sur le type de l'entité.
Definition Item.h:386

Arcane::Item::mutableItemBase
impl::MutableItemBase mutableItemBase() const
Partie interne modifiable de l'entité.
Definition Item.h:374

Arcane::Item::_nbHParent
Int32 _nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:441

Arcane::Item::NULL_ELEMENT
static const Int32 NULL_ELEMENT
Indice d'un élément nul.
Definition Item.h:163

Arcane::Item::isItemWithNodes
bool isItemWithNodes() const
true si l'entité est du genre ItemWithNodes.
Definition Item.h:294

Arcane::Item::Item
Item(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:182

Arcane::Item::_nbEdge
Integer _nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
Definition Item.h:435

Arcane::Item::_nbNode
Integer _nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:433

Arcane::Item::internal
ItemInternal * internal() const
Partie interne de l'entité.
Definition Item.h:348

Arcane::Item::localId
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:219

Arcane::Item::toEdge
Edge toEdge() const
Converti l'entité en le genre Edge.
Definition Item.h:1656

Arcane::Item::Item
Item(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:200

Arcane::Item::Item
Item()=default
Création d'une entité de maillage nulle.

Arcane::Item::isOwn
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253

Arcane::Item::typeName
static String typeName(Int32 type)
Nom du type de maille cell_type.
Definition Item.cc:51

Arcane::Item::isCell
bool isCell() const
true si l'entité est du genre Cell.
Definition Item.h:307

Arcane::Item::owner
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:238

Arcane::Item::m_shared_info
ItemSharedInfo * m_shared_info
Infos partagées entre toutes les entités ayant les mêmes caractéristiques.
Definition Item.h:399

Arcane::Item::LocalIdType
ItemLocalId LocalIdType
Type du localId()
Definition Item.h:108

Arcane::Item::_nbFace
Integer _nbFace() const
Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
Definition Item.h:437

Arcane::Item::toItemWithNodes
ItemWithNodes toItemWithNodes() const
Converti l'entité en le genre ItemWithNodes.
Definition Item.h:1642

Arcane::Item::toDoF
DoF toDoF() const
Converti l'entité en le genre DoF.
Definition Item.h:1684

Arcane::Item::toCell
Cell toCell() const
Converti l'entité en le genre Cell.
Definition Item.h:1670

Arcane::Item::kind
eItemKind kind() const
Genre de l'entité
Definition Item.h:250

Arcane::Item::Tri3
@ Tri3
Elément de type triangle (3 sommets, 2D)
Definition Item.h:149

Arcane::Item::Quad4
@ Quad4
Elément de type quad (4 sommets, 2D)
Definition Item.h:150

Arcane::Item::Pentagon5
@ Pentagon5
Elément de type pentagone (5 sommets, 2D)
Definition Item.h:151

Arcane::Item::Unknown
@ Unknown
Elément de type nul.
Definition Item.h:146

Arcane::Item::Pyramid
@ Pyramid
Elément de type pyramide (5 sommets, 3D)
Definition Item.h:154

Arcane::Item::Bar2
@ Bar2
Elément de type arête (2 sommets, 1D, 2D et 3D)
Definition Item.h:148

Arcane::Item::Vertex
@ Vertex
Elément de type noeud (1 sommet 1D, 2D et 3D)
Definition Item.h:147

Arcane::Item::Hexa
@ Hexa
Elément de type hexaèdre (8 sommets, 3D)
Definition Item.h:156

Arcane::Item::Hexagon6
@ Hexagon6
Elément de type hexagone (6 sommets, 2D)
Definition Item.h:152

Arcane::Item::Penta
@ Penta
Elément de type pentaèdre (6 sommets, 3D)
Definition Item.h:155

Arcane::Item::Wedge8
@ Wedge8
Elément de type prisme à 8 faces (base hexagonale)
Definition Item.h:158

Arcane::Item::Wedge7
@ Wedge7
Elément de type prisme à 7 faces (base pentagonale)
Definition Item.h:157

Arcane::Item::Tetra
@ Tetra
Elément de type tétraédre (4 sommets, 3D)
Definition Item.h:153

Arcane::Item::itemFamily
IItemFamily * itemFamily() const
Famille dont est issue l'entité
Definition Item.h:247

Arcane::Item::toParticle
Particle toParticle() const
Converti l'entité en le genre Particle.
Definition Item.h:1677

Arcane::Item::Item
constexpr __host__ __device__ Item(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:193

Arcane::Item::uniqueId
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225

Arcane::Item::Item
constexpr __host__ __device__ Item(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:172

Arcane::Item::null
constexpr bool null() const
true si l'entité est nul (i.e. non connecté au maillage)
Definition Item.h:216

Arcane::Item::_flags
Int32 _flags() const
Flags de l'entité
Definition Item.h:431

Arcane::Item::itemLocalId
constexpr ItemLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:222

Arcane::Item::isFace
bool isFace() const
true si l'entité est du genre Edge.
Definition Item.h:319

Arcane::Item::toFace
Face toFace() const
Converti l'entité en le genre Edge.
Definition Item.h:1663

Arcane::Item::isNode
bool isNode() const
true si l'entité est du genre Node.
Definition Item.h:301

Arcane::Item::_nbParent
Integer _nbParent() const
Nombre de parent pour les sous-maillages.
Definition Item.h:445

Arcane::Item::_nbCell
Integer _nbCell() const
Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
Definition Item.h:439

Arcane::Item::isEdge
bool isEdge() const
true si l'entité est du genre Edge.
Definition Item.h:313

Arcane::Item::parent
Item parent(Int32 i) const
i-ème parent pour les sous-maillages
Definition Item.h:286

Arcane::Item::itemTypeId
ItemTypeId itemTypeId() const
Type de l'entité
Definition Item.h:244

Arcane::Item::parent
Item parent() const
premier parent pour les sous-maillages
Definition Item.h:289

Arcane::Item::isDoF
bool isDoF() const
true is l'entité est du genre DoF
Definition Item.h:331

Arcane::Item::m_local_id
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
Definition Item.h:409

Arcane::Item::itemBase
impl::ItemBase itemBase() const
Partie interne de l'entité.
Definition Item.h:363

Arcane::Item::isShared
bool isShared() const
Vrai si l'entité est partagé d'autres sous-domaines.
Definition Item.h:265

Arcane::Item::isParticle
bool isParticle() const
true is l'entité est du genre Particle.
Definition Item.h:325

Arcane::Item::_nbHChildren
Int32 _nbHChildren() const
Nombre d' enfants pour l'AMR.
Definition Item.h:443

Arcane::Item::type
Int16 type() const
Type de l'entité
Definition Item.h:241

Arcane::Item::operator=
Item & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:207

Arcane::Item::toNode
Node toNode() const
Converti l'entité en le genre Node.
Definition Item.h:1649

Arcane::Node
Noeud d'un maillage.
Definition Item.h:573

Arcane::Node::cell
Cell cell(Int32 i) const
i-ème maille du noeud
Definition Item.h:1584

Arcane::Node::faceIds
FaceLocalIdView faceIds() const
Liste des faces du noeud.
Definition Item.h:686

Arcane::Node::Node
Node(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:631

Arcane::Node::cells
CellConnectedListViewType cells() const
Liste des mailles du noeud.
Definition Item.h:680

Arcane::Node::_internalActiveCells
CellVectorView _internalActiveCells(Int32Array &local_ids) const
Enumére les mailles connectées au noeud.
Definition Item.h:694

Arcane::Node::Node
Node(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:619

Arcane::Node::edgeIds
EdgeLocalIdView edgeIds() const
Liste des arêtes du noeud.
Definition Item.h:683

Arcane::Node::Node
Node(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:607

Arcane::Node::itemLocalId
NodeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:644

Arcane::Node::Node
Node(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:627

Arcane::Node::faceId
FaceLocalId faceId(Int32 i) const
i-ème face du noeud
Definition Item.h:668

Arcane::Node::faces
FaceConnectedListViewType faces() const
Liste des faces du noeud.
Definition Item.h:677

Arcane::Node::operator=
Node & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:635

Arcane::Node::face
Face face(Int32 i) const
i-ème face du noeud
Definition Item.h:1578

Arcane::Node::nbEdge
Int32 nbEdge() const
Nombre d'arêtes connectées au noeud.
Definition Item.h:647

Arcane::Node::Node
Node(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:623

Arcane::Node::cellIds
CellLocalIdView cellIds() const
Liste des mailles du noeud.
Definition Item.h:689

Arcane::Node::edge
Edge edge(Int32 i) const
i-ème arête du noeud
Definition Item.h:1572

Arcane::Node::nbFace
Int32 nbFace() const
Nombre de faces connectées au noeud.
Definition Item.h:650

Arcane::Node::nbCell
Int32 nbCell() const
Nombre de mailles connectées au noeud.
Definition Item.h:653

Arcane::Node::edges
EdgeConnectedListViewType edges() const
Liste des arêtes du noeud.
Definition Item.h:674

Arcane::Node::cellId
CellLocalId cellId(Int32 i) const
i-ème maille du noeud
Definition Item.h:671

Arcane::Node::edgeId
EdgeLocalId edgeId(Int32 i) const
i-ème arête du noeud
Definition Item.h:665

Arcane::Node::LocalIdType
NodeLocalId LocalIdType
Type du localId()
Definition Item.h:613

Arcane::Particle
Particule.
Definition Item.h:1397

Arcane::Particle::Particle
Particle(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1430

Arcane::Particle::Particle
Particle()=default
Constructeur d'une particule nulle.

Arcane::Particle::hasCell
bool hasCell() const
Vrai si la particule est dans une maille du maillage.
Definition Item.h:1465

Arcane::Particle::Particle
Particle(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:1414

Arcane::Particle::itemLocalId
ParticleLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1452

Arcane::Particle::cell
Cell cell() const
Maille à laquelle appartient la particule. Il faut appeler setCell() avant d'appeler cette fonction....
Definition Item.h:1459

Arcane::Particle::cellId
CellLocalId cellId() const
Maille connectée à la particule.
Definition Item.h:1462

Arcane::Particle::Particle
Particle(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1438

Arcane::Particle::cellOrNull
Cell cellOrNull() const
Maille à laquelle appartient la particule ou maille nulle. Retourne cell() si la particule est dans u...
Definition Item.h:1472

Arcane::Particle::operator=
Particle & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1443

Arcane::Particle::LocalIdType
ParticleLocalId LocalIdType
Type du localId()
Definition Item.h:1420

Arcane::Particle::Particle
Particle(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1434

Arcane::Particle::Particle
Particle(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1426

Arcane::SimdItemT
Gère un vecteur d'entité ItemType.
Definition SimdItem.h:236

Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70

Arcane::NodeLocalIdView
ItemLocalIdListViewT< Node > NodeLocalIdView
Vue sur les localId() d'une liste de noeuds.
Definition ItemTypes.h:407

Arcane::CellVectorView
ItemVectorViewT< Cell > CellVectorView
Vue sur un vecteur de mailles.
Definition ItemTypes.h:304

Arcane::EdgeLocalIdView
ItemLocalIdListViewT< Edge > EdgeLocalIdView
Vue sur les localId() d'une liste d'arêtes.
Definition ItemTypes.h:417

Arcane::FaceLocalIdView
ItemLocalIdListViewT< Face > FaceLocalIdView
Vue sur les localId() d'une liste de faces.
Definition ItemTypes.h:427

Arcane::CellLocalIdView
ItemLocalIdListViewT< Cell > CellLocalIdView
Vue sur les localId() d'une liste de mailles.
Definition ItemTypes.h:437

Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36

Arcane::NodeConnectedListViewType
NodeConnectedListView NodeConnectedListViewType
Liste de noeuds connectés.
Definition ItemTypes.h:349

Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240

Arcane::CellConnectedListViewType
CellConnectedListView CellConnectedListViewType
Liste de mailles connectées.
Definition ItemTypes.h:355

Arcane::operator<
bool operator<(const Item &item1, const Item &item2)
Compare deux entités.
Definition Item.h:542

Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:168

Arcane::IK_Particle
@ IK_Particle
Entité de maillage de genre particule.
Definition ArcaneTypes.h:174

Arcane::IK_Node
@ IK_Node
Entité de maillage de genre noeud.
Definition ArcaneTypes.h:169

Arcane::IK_Cell
@ IK_Cell
Entité de maillage de genre maille.
Definition ArcaneTypes.h:172

Arcane::IK_Unknown
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
Definition ArcaneTypes.h:175

Arcane::IK_Face
@ IK_Face
Entité de maillage de genre face.
Definition ArcaneTypes.h:171

Arcane::IK_DoF
@ IK_DoF
Entité de maillage de genre degre de liberte.
Definition ArcaneTypes.h:173

Arcane::IK_Edge
@ IK_Edge
Entité de maillage de genre arête.
Definition ArcaneTypes.h:170

Arcane::Int16
std::int16_t Int16
Type entier signé sur 16 bits.
Definition ArccoreGlobal.h:182

Arcane::Int32Array
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214

Arcane::EdgeConnectedListViewType
EdgeConnectedListView EdgeConnectedListViewType
Liste d'arêtes connectées.
Definition ItemTypes.h:351

Arcane::FaceConnectedListViewType
FaceConnectedListView FaceConnectedListViewType
Liste de faces connectées.
Definition ItemTypes.h:353

Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184