d5/d4d/ItemInternal_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

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

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

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

/*                                                                           */

/* Partie interne d'une entité.                                              */

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

#ifndef ARCANE_CORE_ITEMINTERNAL_H

#define ARCANE_CORE_ITEMINTERNAL_H

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

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


#include "arcane/utils/Array.h"


#include "arcane/core/ItemTypes.h"

#include "arcane/core/ItemIndexedListView.h"

#include "arcane/core/ItemSharedInfo.h"

#include "arcane/core/ItemUniqueId.h"

#include "arcane/core/ItemLocalIdListView.h"

#include "arcane/core/ItemTypeId.h"

#include "arcane/core/ItemFlags.h"

#include "arcane/core/ItemConnectivityContainerView.h"

#include "arcane/core/ItemInternalVectorView.h"


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

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


#ifdef null

#undef null

#endif


//#define ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO


#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

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

#else

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

#endif


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

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


namespace Arcane::mesh

{

class IncrementalItemConnectivityBase;

class PolyhedralFamily;

class PolyhedralMeshImpl;

class FaceFamily;

class MeshRefinement;

}

namespace Arcane::Materials

{

class ConstituentItemSharedInfo;

}

namespace Arcane

{

class ItemInternalCompatibility;


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

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


class ARCANE_CORE_EXPORT ItemBaseBuildInfo

{

 public:

  ItemBaseBuildInfo() = default;

  ItemBaseBuildInfo(Int32 local_id,ItemSharedInfo* shared_info)

  : m_local_id(local_id), m_shared_info(shared_info) {}

 public:

  Int32 m_local_id = NULL_ITEM_LOCAL_ID;

  ItemSharedInfo* m_shared_info = nullptr;

};


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

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


class ARCANE_CORE_EXPORT ItemInternalConnectivityList

{

  // IMPORTANT: Cette structure doit avoir le même agencement mémoire

  // que la structure C# de même nom.


  friend class ItemBase;

  friend class ItemInternal;

  friend class Item;


  // Pour accès à _setConnectivity*

  friend mesh::IncrementalItemConnectivityBase;

  friend mesh::PolyhedralFamily;

  friend mesh::PolyhedralMeshImpl;


  // Pour accès à m_items

  friend mesh::ItemFamily;


 private:


  struct Int32View

  {

   public:

    Int32 operator[](Int32 index) const

    {

#ifdef ARCANE_CHECK

      if (index==NULL_ITEM_LOCAL_ID){

        // Pour l'entité nulle, la taille doit être 0.

        if (m_size!=0)

          arcaneRangeError(index,m_size);

      }

      else

        ARCANE_CHECK_AT(index,m_size);

#endif

      return m_data[index];

    }

    void operator=(ConstArrayView<Int32> v)

    {

      m_data = v.data();

      m_size = v.size();

    }

    // Il faut que data[NULL_ITEM_LOCAL_ID] soit valide.

    // Il faut donc que (data-1) pointe vers une adresse valide

    void setNull(const Int32* data)

    {

      m_data = data;

      m_size = 0;

    }

    operator ConstArrayView<Int32>() const

    {

      return ConstArrayView<Int32>(m_size,m_data);

    }

    operator SmallSpan<const Int32>() const

    {

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

    }

   private:

    Int32 m_size;

    const Int32* m_data;

  };


 public:


  enum

  {

    NODE_IDX = 0,

    EDGE_IDX = 1,

    FACE_IDX = 2,

    CELL_IDX = 3,

    HPARENT_IDX = 4,

    HCHILD_IDX = 5,

    MAX_ITEM_KIND = 6

  };


 public:


  static ItemInternalConnectivityList nullInstance;


 public:


  ItemInternalConnectivityList()

  : m_items(nullptr)

  {

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

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

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

      m_kind_info[i].m_max_nb_item = 0;

    }


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

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

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

    }

  }


 public:


  void updateMeshItemInternalList()

  {

#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

    m_shared_infos.m_node = m_items->m_node_shared_info;

    m_shared_infos.m_edge = m_items->m_edge_shared_info;

    m_shared_infos.m_face = m_items->m_face_shared_info;

    m_shared_infos.m_cell = m_items->m_cell_shared_info;

#endif

  }


 private:


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

  {

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

  }


  Int64 nbAccess() const { return 0; }

  Int64 nbAccessAll() const { return 0; }


 private:


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

  {

    m_container[item_kind].m_indexes = v;

  }


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

  {

    m_container[item_kind].m_list = v;

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

  }


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

  {

    m_container[item_kind].m_nb_item = v;

  }


  void _setMaxNbConnectedItem(Int32 item_kind,Int32 v)

  {

    m_kind_info[item_kind].m_max_nb_item = v;

  }


 public:


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


  Int32ConstArrayView connectivityIndex(Int32 item_kind) const

  {

    return m_container[item_kind].m_indexes;

  }


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


  Int32ConstArrayView connectivityList(Int32 item_kind) const

  {

    return m_container[item_kind].m_list;

  }


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


  Int32ConstArrayView connectivityNbItem(Int32 item_kind) const

  {

    return m_container[item_kind].m_nb_item;

  }


 public:


  Int32 maxNbConnectedItem(Int32 item_kind) const

  {

    return m_kind_info[item_kind].m_max_nb_item;

  }


  ItemConnectivityContainerView containerView(Int32 item_kind) const

  {

    return m_container[item_kind].containerView();

  }


 public:


  ItemBaseBuildInfo nodeBase(Int32 lid,Int32 aindex) const

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

  ItemBaseBuildInfo edgeBase(Int32 lid,Int32 aindex) const

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

  ItemBaseBuildInfo faceBase(Int32 lid,Int32 aindex) const

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

  ItemBaseBuildInfo cellBase(Int32 lid,Int32 aindex) const

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

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

  {

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

  }

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

  {

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

  }


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

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

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

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


 private:


  // Ces 4 méthodes sont encore utilisées par ItemBase via internalNodes(), internalEdges(), ...

  // On pourra les supprimer quand ces méthodes obsolètes seront supprimées

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

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

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

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


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

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

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

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


 private:


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

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

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

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

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

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


 private:


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

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

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

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

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

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


 private:


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

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

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

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

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

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


 private:


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

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

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

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

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


 private:


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

  {

    return m_container[item_kind].itemLocalIdListView(lid);

  }


 private:


  // NOTE : à terme, il faudra fusionner cette classe avec ItemConnectivityContainerView


  struct Container

  {

    impl::ItemLocalIdListContainerView itemLocalIdListView(Int32 lid) const

    {

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

    }

    const Int32* itemLocalIdsData(Int32 lid) const

    {

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

    }

    Int32 itemLocalId(Int32 lid,Integer index) const

    {

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

    }

    ItemConnectivityContainerView containerView() const

    {

      return ItemConnectivityContainerView( m_list, m_indexes, m_nb_item );

    }

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

    {

#ifdef ARCANE_USE_OFFSET_FOR_CONNECTIVITY

      return m_offset[lid];

#else

      return 0;

#endif

    }


   public:


    ConstArrayView<Int32> m_indexes;

    Int32View m_nb_item;

    ConstArrayView<Int32> m_list;

    ConstArrayView<Int32> m_offset;

  };


  struct KindInfo

  {

    Int32 m_max_nb_item;

    Int32 m_nb_item_null_data[2];

  };


 private:


  Container m_container[MAX_ITEM_KIND];

  KindInfo m_kind_info[MAX_ITEM_KIND];


  MeshItemInternalList* m_items;


 private:


#ifdef ARCANE_CONNECTIVITYLIST_USE_OWN_SHAREDINFO

  impl::MeshItemSharedInfoList m_shared_infos;

#endif

};


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

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


class ARCANE_CORE_EXPORT ItemBase

: public ItemFlags

{

  friend class ::Arcane::ItemInternal;

  friend class ::Arcane::Item;

  friend class ::Arcane::ItemInternalCompatibility;

  friend Arcane::Materials::ConstituentItemSharedInfo;

  friend class ::Arcane::ItemEnumerator;

  friend MutableItemBase;

  // Pour _internalActiveCells2().

  friend class ::Arcane::Node;

  // Pour _itemInternal()

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

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


 private:


  ItemBase(Int32 local_id,ItemSharedInfo* shared_info)

  : m_local_id(local_id), m_shared_info(shared_info) {}


 public:


  ItemBase() : m_shared_info(ItemSharedInfo::nullItemSharedInfoPointer) {}

  ItemBase(ItemBaseBuildInfo x) : m_local_id(x.m_local_id), m_shared_info(x.m_shared_info) {}


 public:


  // TODO: A supprimer à terme

  inline ItemBase(ItemInternal* x);


 public:


  Int32 localId() const { return m_local_id; }

  inline ItemLocalId itemLocalId() const;


  ItemUniqueId uniqueId() const

  {

#ifdef ARCANE_CHECK

    if (m_local_id!=NULL_ITEM_LOCAL_ID)

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

#endif

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

  }


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


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


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

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

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

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

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

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

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


 public:


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

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

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


  inline Int32 level() const

  {

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

      return 0;

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

  }


  inline bool isAncestor() const

  {

    if (this->isActive())

      return false;

    if (!this->hasHChildren())

      return false;

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

      return true;

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

  }


  inline bool hasHChildren () const

  {

    if (this->nbHChildren() == 0) // TODO ? à vérifier !

      return false;

    else

      return true;

  }


  inline bool isActive() const

  {

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

      return false;

    else

      return true;

  }


  inline  bool isSubactive() const

  {

    if (this->isActive())

      return false;

    if (!this->hasHChildren())

      return true;

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

  }


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

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

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

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

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

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


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

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


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

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


  ItemBase backCell() const

  {

    if (flags() & II_HasBackCell)

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

    return {};

  }


  Int32 backCellId() const

  {

    if (flags() & II_HasBackCell)

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

    return NULL_ITEM_LOCAL_ID;

  }


  ItemBase frontCell() const

  {

    if (flags() & II_HasFrontCell)

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

    return {};

  }


  Int32 frontCellId() const

  {

    if (flags() & II_HasFrontCell)

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

    return NULL_ITEM_LOCAL_ID;

  }


  ItemBase masterFace() const

  {

    if (flags() & II_SlaveFace)

      return faceBase(0);

    return {};

  }

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


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


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


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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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

  inline ItemBase parentBase(Int32 index) const;


 public:


  Int32 whichChildAmI(Int32 local_id) const;


 public:


  ItemBase topHParentBase() const;


 public:


  inline MutableItemBase toMutable();


 public:


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

  inline ItemInternal* itemInternal() const;


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

  ItemInternalVectorView _internalActiveCells(Int32Array& local_ids) const

  {

    return _internalActiveCells2(local_ids);

  }


 private:


  Int32 _nbLinearNode() const;


 private:


  Int32 m_local_id = NULL_ITEM_LOCAL_ID;


  Int32 m_padding = 0;


  ItemSharedInfo* m_shared_info = nullptr;


 private:


  ItemInternalConnectivityList* _connectivity() const

  {

    return m_shared_info->m_connectivity;

  }

  void _setFromInternal(ItemBase* rhs)

  {

    m_local_id = rhs->m_local_id;

    m_shared_info = rhs->m_shared_info;

  }

  void _setFromInternal(const ItemBase& rhs)

  {

    m_local_id = rhs.m_local_id;

    m_shared_info = rhs.m_shared_info;

  }

  ItemInternalVectorView _internalActiveCells2(Int32Array& local_ids) const;

  inline ItemInternal* _itemInternal() const;

};


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

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


class ARCANE_CORE_EXPORT MutableItemBase

: public ItemBase

{

  friend class ::Arcane::Item;

  friend ItemBase;

  // Pour _setFaceBackAndFrontCell()

  friend Arcane::mesh::FaceFamily;


 private:


  MutableItemBase(Int32 local_id,ItemSharedInfo* shared_info)

  : ItemBase(local_id, shared_info) {}


 public:


  MutableItemBase() = default;

  MutableItemBase(ItemBaseBuildInfo x) : ItemBase(x) {}

  explicit MutableItemBase(const ItemBase& x)

  : ItemBase(x)

  {}


 public:


  // TODO: A supprimer à terme

  inline MutableItemBase(ItemInternal* x);


 public:


  void setUniqueId(Int64 uid)

  {

    _checkUniqueId(uid);

    m_shared_info->m_unique_ids[m_local_id] = uid;

  }


  void unsetUniqueId();


  void setOwner(Integer suid,Int32 current_sub_domain)

  {

    m_shared_info->_setOwnerV2(m_local_id,suid);

    int f = flags();

    if (suid==current_sub_domain)

      f |= II_Own;

    else

      f &= ~II_Own;

    setFlags(f);

  }


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


  void addFlags(Int32 added_flags)

  {

    Int32 f = this->flags();

    f |= added_flags;

    this->setFlags(f);

  }


  void removeFlags(Int32 removed_flags)

  {

    Int32 f = this->flags();

    f &= ~removed_flags;

    this->setFlags(f);

  }


  void setDetached(bool v)

  {

    int f = flags();

    if (v)

      f |= II_Detached;

    else

      f &= ~II_Detached;

    setFlags(f);

  }


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

  {

    setUniqueId(uid);

    setFlags(0);

    setOwner(aowner,owner_rank);

  }


  void setLocalId(Int32 local_id)

  {

    m_local_id = local_id;

  }


  void setParent(Int32 aindex,Int32 parent_local_id)

  {

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

  }


 private:


  void _setFaceBackAndFrontCells(Int32 back_cell_lid, Int32 front_cell_lid);


  void _checkUniqueId(Int64 new_uid) const;


  inline void _setFaceInfos(Int32 mod_flags);

};


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

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


class ARCANE_CORE_EXPORT ItemInternal

: public impl::MutableItemBase

{

  // Pour accès à _setSharedInfo()

  friend class mesh::DynamicMeshKindInfos;

  friend class mesh::ItemFamily;


 public:


  static ItemInternal nullItemInternal;

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


 public:


  // Il faut utiliser la méthode correspondante de ItemBase


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

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

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


  ItemInternal* backCell() const

  {

    if (flags() & II_HasBackCell)

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

    return nullItem();

  }


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


  ItemInternal* frontCell() const

  {

    if (flags() & II_HasFrontCell)

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

    return nullItem();

  }


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

  ItemInternal* masterFace() const

  {

    if (flags() & II_SlaveFace)

      return _internalFace(0);

    return nullItem();

  }


 public:


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

  ItemSharedInfo* sharedInfo() const { return m_shared_info; }


 public:


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

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

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

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

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

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

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

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


 public:


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

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

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

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

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

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

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

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

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

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

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

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

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

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


 public:


  const ItemInternal* topHParent() const;

  ItemInternal* topHParent();


 public:


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

  Int32 dataIndex() { return 0; }


 public:


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

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


  Int32 whichChildAmI(const ItemInternal *iitem) const;


 public:


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

  constexpr Integer neededMemory() const { return 0; }


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

  constexpr Integer minimumNeededMemory() const { return 0; }


 public:


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

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

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

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

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

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

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

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


 public:


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

  void setDataIndex(Integer);


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

  void setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)

  {

    _setSharedInfo(shared_infos,type_id);

  }


 public:


  typedef ItemInternal* ItemInternalPtr;


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


  static ItemSharedInfo* _getSharedInfo(const ItemInternalPtr* items)

  {

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

  }


 private:


  void _setSharedInfo(ItemSharedInfo* shared_infos,ItemTypeId type_id)

  {

    m_shared_info = shared_infos;

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

  }


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

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

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

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

};


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

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


ItemBase::

ItemBase(ItemInternal* x)

: m_local_id(x->m_local_id)

, m_shared_info(x->m_shared_info)

{}


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

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


MutableItemBase::

MutableItemBase(ItemInternal* x)

: ItemBase(x)

{}


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

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


inline ItemLocalId::

ItemLocalId(ItemInternal* item)

: m_local_id(item->localId())

{

}


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

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


// TODO: ajouter vérification du bon type

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

ItemLocalIdT(ItemInternal* item)

: ItemLocalId(item->localId())

{

}


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

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


inline ItemInternal* impl::ItemBase::

itemInternal() const

{

  if (m_local_id!=NULL_ITEM_LOCAL_ID)

    return m_shared_info->m_items_internal[m_local_id];

  return ItemInternal::nullItem();

}


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

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


inline ItemInternal* impl::ItemBase::

_itemInternal() const

{

  if (m_local_id!=NULL_ITEM_LOCAL_ID)

    return m_shared_info->m_items_internal[m_local_id];

  return ItemInternal::nullItem();

}


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

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


inline impl::ItemBase impl::ItemBase::

parentBase(Int32 index) const

{

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

}


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

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


inline impl::MutableItemBase impl::ItemBase::

toMutable()

{

  return MutableItemBase(m_local_id,m_shared_info);

}


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

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


inline ItemLocalId impl::ItemBase::

itemLocalId() const

{

  return ItemLocalId(m_local_id);

}


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

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


class ItemInternalCompatibility

{

  friend class SimdItemBase;

  friend class SimdItemDirectBase;

  friend class SimdItem;

  friend class SimdItemEnumeratorBase;

  friend class ItemVectorView;

  template<typename T> friend class ItemEnumeratorBaseT;

  friend class mesh::DynamicMeshKindInfos;

  friend class TotalviewAdapter;

  template<int Extent> friend class ItemConnectedListView;


 private:


  typedef ItemInternal* ItemInternalPtr;

  static ItemSharedInfo* _getSharedInfo(const ItemInternal* item)

  {

    return item->m_shared_info;

  }

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

  {

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

  }

  static const ItemInternalPtr* _getItemInternalPtr(ItemSharedInfo* shared_info)

  {

    ARCANE_CHECK_PTR(shared_info);

    return shared_info->m_items_internal.data();

  }

};


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

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


} // End namespace Arcane


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

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


#endif

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

Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533

Arcane::ConstArrayView::data
constexpr const_pointer data() const noexcept
Pointeur sur la mémoire allouée.
Definition arccore/src/base/arccore/base/ArrayView.h:759

Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:713

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

Arcane::ItemBaseBuildInfo
Classe pour construire une instance de ItemBase.
Definition ItemInternal.h:70

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

Arcane::ItemBase::nbEdge
Integer nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
Definition ItemInternal.h:489

Arcane::ItemBase::itemLocalId
ItemLocalId itemLocalId() const
Numéro local (au sous-domaine) de l'entité
Definition ItemInternal.h:1159

Arcane::ItemBase::isSuppressed
bool isSuppressed() const
Vrai si l'entité est supprimée.
Definition ItemInternal.h:587

Arcane::ItemBase::uniqueId
ItemUniqueId uniqueId() const
Numéro unique de l'entité
Definition ItemInternal.h:468

Arcane::ItemBase::backCellId
Int32 backCellId() const
Maille derrière l'entité (NULL_ITEM_LOCAL_ID si aucune)
Definition ItemInternal.h:603

Arcane::ItemBase::m_padding
Int32 m_padding
Champ servant uniquement à gérer explicitement l'alignement.
Definition ItemInternal.h:741

Arcane::ItemBase::kind
eItemKind kind() const
Genre de l'entité
Definition ItemInternal.h:571

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

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

Arcane::ItemBase::family
IItemFamily * family() const
Famille dont est issue l'entité
Definition ItemInternal.h:569

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

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

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

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

Arcane::ItemBase::toMutable
MutableItemBase toMutable()
Interface modifiable de cette entité
Definition ItemInternal.h:1150

Arcane::ItemBase::flags
Int32 flags() const
Flags de l'entité
Definition ItemInternal.h:484

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

Arcane::ItemBase::backCell
ItemBase backCell() const
Maille derrière l'entité (nullItem() si aucune)
Definition ItemInternal.h:596

Arcane::ItemBase::isDetached
bool isDetached() const
Vrai si l'entité est détachée.
Definition ItemInternal.h:589

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

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

Arcane::ItemBase::nodeList
impl::ItemIndexedListView< DynExtent > nodeList() const
Méthodes utilisant les nouvelles connectivités pour accéder aux informations de connectivité....
Definition ItemInternal.h:678

Arcane::ItemBase::typeInfo
ItemTypeInfo * typeInfo() const
Type de l'entité.
Definition ItemInternal.h:508

Arcane::ItemBase::typeId
Int16 typeId() const
Type de l'entité
Definition ItemInternal.h:504

Arcane::ItemBase::nbHParent
Int32 nbHParent() const
Nombre de parents pour l'AMR.
Definition ItemInternal.h:495

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

Arcane::ItemBase::isOwn
bool isOwn() const
Vrai si l'entité appartient au sous-domaine.
Definition ItemInternal.h:577

Arcane::ItemBase::itemTypeId
ItemTypeId itemTypeId() const
Type de l'entité
Definition ItemInternal.h:506

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

Arcane::ItemBase::nbHChildren
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition ItemInternal.h:497

Arcane::ItemBase::isNull
bool isNull() const
Vrai si l'entité est l'entité nulle.
Definition ItemInternal.h:575

Arcane::ItemBase::nbNode
Integer nbNode() const
Nombre de noeuds de l'entité
Definition ItemInternal.h:487

Arcane::ItemBase::boundaryCell
ItemBase boundaryCell() const
Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
Definition ItemInternal.h:594

Arcane::ItemBase::isBoundary
bool isBoundary() const
true si l'entité est sur la frontière
Definition ItemInternal.h:592

Arcane::ItemBase::internalNodes
ItemInternalVectorView internalNodes() const
Méthodes utilisant les nouvelles connectivités pour accéder aux informations de connectivité....
Definition ItemInternal.h:658

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:744

Arcane::ItemBase::frontCellId
Int32 frontCellId() const
Maille devant l'entité (NULL_ITEM_LOCAL_ID si aucune)
Definition ItemInternal.h:617

Arcane::ItemBase::nbParent
Integer nbParent() const
Nombre de parent pour les sous-maillages.
Definition ItemInternal.h:499

Arcane::ItemBase::null
bool null() const
Vrai si l'entité est l'entité nulle.
Definition ItemInternal.h:573

Arcane::ItemBase::frontCell
ItemBase frontCell() const
Maille devant l'entité (nullItem() si aucune)
Definition ItemInternal.h:610

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

Arcane::ItemBase::isSlaveFace
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Definition ItemInternal.h:633

Arcane::ItemConnectivityContainerView
Vues sur les conteneurs contenant les connectivités. Cette classe permet de rendre opaque en dehors d...
Definition ItemConnectivityContainerView.h:44

Arcane::ItemFlags
Flags pour les caractéristiques des entités.
Definition ItemFlags.h:31

Arcane::ItemFlags::II_FrontCellIsFirst
@ II_FrontCellIsFirst
La première maille de l'entité est la maille devant.
Definition ItemFlags.h:46

Arcane::ItemFlags::II_MasterFace
@ II_MasterFace
L'entité est une face maître d'une interface.
Definition ItemFlags.h:57

Arcane::ItemFlags::II_Inactive
@ II_Inactive
L'entité est inactive //COARSEN_INACTIVE,.
Definition ItemFlags.h:66

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_Suppressed
@ II_Suppressed
L'entité vient d'être supprimée.
Definition ItemFlags.h:50

Arcane::ItemFlags::II_Detached
@ II_Detached
L'entité est détachée du maillage.
Definition ItemFlags.h:58

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

Arcane::ItemFlags::II_SlaveFace
@ II_SlaveFace
L'entité est une face esclave d'une interface.
Definition ItemFlags.h:56

Arcane::ItemFlags::II_CoarsenInactive
@ II_CoarsenInactive
L'entité est inactive et a des enfants tagués pour déraffinement.
Definition ItemFlags.h:67

Arcane::ItemFlags::II_HasFrontCell
@ II_HasFrontCell
L'entité a une maille devant.
Definition ItemFlags.h:44

Arcane::ItemFlags::II_BackCellIsFirst
@ II_BackCellIsFirst
La première maille de l'entité est la maille derrière.
Definition ItemFlags.h:47

Arcane::ItemInternalCompatibility
Méthodes pour conversions entre différentes classes de gestion des entités.
Definition ItemInternal.h:1175

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

Arcane::ItemInternalConnectivityList
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Definition ItemInternal.h:89

Arcane::ItemInternalConnectivityList::connectivityNbItem
Int32ConstArrayView connectivityNbItem(Int32 item_kind) const
Tableau contenant le nombre d'entités connectées pour les entités de genre item_kind.
Definition ItemInternal.h:256

Arcane::ItemInternalConnectivityList::nbAccess
Int64 nbAccess() const
Nombre d'appel à itemLocalId()
Definition ItemInternal.h:212

Arcane::ItemInternalConnectivityList::connectivityList
Int32ConstArrayView connectivityList(Int32 item_kind) const
Tableau contenant la liste des connectivités pour les entités de genre item_kind.
Definition ItemInternal.h:250

Arcane::ItemInternalConnectivityList::_setConnectivityNbItem
void _setConnectivityNbItem(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau contenant le nombre d'entités connectées.
Definition ItemInternal.h:230

Arcane::ItemInternalConnectivityList::maxNbConnectedItem
Int32 maxNbConnectedItem(Int32 item_kind) const
Nombre maximum d'entités connectées.
Definition ItemInternal.h:264

Arcane::ItemInternalConnectivityList::itemLocalId
Int32 itemLocalId(Int32 item_kind, Int32 lid, Integer index) const
localId() de la index-ème entité de type item_kind connectés à l'entité de de localid() lid.
Definition ItemInternal.h:207

Arcane::ItemInternalConnectivityList::nbAccessAll
Int64 nbAccessAll() const
Nombre d'appel à itemLocalIds()
Definition ItemInternal.h:214

Arcane::ItemInternalConnectivityList::_setConnectivityList
void _setConnectivityList(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau contenant la liste des connectivités.
Definition ItemInternal.h:224

Arcane::ItemInternalConnectivityList::connectivityIndex
Int32ConstArrayView connectivityIndex(Int32 item_kind) const
Tableau d'index des connectivités pour les entités de genre item_kind.
Definition ItemInternal.h:244

Arcane::ItemInternalConnectivityList::_setConnectivityIndex
void _setConnectivityIndex(Int32 item_kind, ConstArrayView< Int32 > v)
Positionne le tableau d'index des connectivités.
Definition ItemInternal.h:219

Arcane::ItemInternalConnectivityList::_setMaxNbConnectedItem
void _setMaxNbConnectedItem(Int32 item_kind, Int32 v)
Positionne le nombre maximum d'entités connectées.
Definition ItemInternal.h:235

Arcane::ItemInternalVectorView
Vue interne sur un tableau d'entités.
Definition ItemInternalVectorView.h:124

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

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

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

Arcane::ItemInternal::minimumNeededMemory
constexpr Integer minimumNeededMemory() const
Mémoire minimale nécessaire pour stocker les infos de l'entité (sans tampon)
Definition ItemInternal.h:1029

Arcane::ItemInternal::neededMemory
constexpr Integer neededMemory() const
Mémoire nécessaire pour stocker les infos de l'entité
Definition ItemInternal.h:1025

Arcane::ItemInternal::boundaryCell
ItemInternal * boundaryCell() const
Maille connectée à l'entité si l'entité est une entité sur la frontière (0 si aucune)
Definition ItemInternal.h:929

Arcane::ItemInternal::sharedInfo
ItemSharedInfo * sharedInfo() const
Infos partagées de l'entité.
Definition ItemInternal.h:958

Arcane::ItemInternal::frontCell
ItemInternal * frontCell() const
Maille devant l'entité (nullItem() si aucune)
Definition ItemInternal.h:940

Arcane::ItemInternal::backCell
ItemInternal * backCell() const
Maille derrière l'entité (nullItem() si aucune)
Definition ItemInternal.h:932

Arcane::ItemInternal::nullItemInternal
static ItemInternal nullItemInternal
Entité nulle.
Definition ItemInternal.h:920

Arcane::ItemInternal::parentPtr
Int32 * parentPtr()
Pointeur sur la liste des parents.
Definition ItemInternal.h:1012

Arcane::ItemLocalIdT
Index d'une entité ItemType dans une variable.
Definition ItemLocalId.h:90

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::ItemTypeId
Type d'une entité (Item).
Definition ItemTypeId.h:32

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

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

Arcane::Materials::ConstituentItemSharedInfo
Informations partagées sur les 'ComponentItem'.
Definition ConstituentItemSharedInfo.h:115

Arcane::MeshItemInternalList
Tableaux d'indirection sur les entités d'un maillage.
Definition MeshItemInternalList.h:79

Arcane::MutableItemBase::setOwner
void setOwner(Integer suid, Int32 current_sub_domain)
Positionne le numéro du sous-domaine propriétaire de l'entité.
Definition ItemInternal.h:821

Arcane::MutableItemBase::setDetached
void setDetached(bool v)
Positionne l'état détachée de l'entité
Definition ItemInternal.h:852

Arcane::MutableItemBase::setFlags
void setFlags(Int32 f)
Positionne les flags de l'entité
Definition ItemInternal.h:833

Arcane::MutableItemBase::unsetUniqueId
void unsetUniqueId()
Annule l'uniqueId a la valeur NULL_ITEM_UNIQUE_ID.
Definition ItemInternal.cc:53

Arcane::MutableItemBase::setParent
void setParent(Int32 aindex, Int32 parent_local_id)
Positionne le i-ème parent (actuellement aindex doit valoir 0)
Definition ItemInternal.h:875

Arcane::MutableItemBase::addFlags
void addFlags(Int32 added_flags)
Ajoute les flags \added_flags à ceux de l'entité
Definition ItemInternal.h:836

Arcane::MutableItemBase::removeFlags
void removeFlags(Int32 removed_flags)
Supprime les flags \added_flags de ceux de l'entité
Definition ItemInternal.h:844

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

Arcane::SmallSpan
Vue d'un tableau d'éléments de type T.
Definition Span.h:673

Arcane::impl::ItemIndexedListView
Vue interne sur un tableau d'entités.
Definition ItemIndexedListView.h:44

Arcane::impl::ItemLocalIdListContainerView
Vue sur le conteneur d'une liste de ItemLocalId.
Definition ItemLocalIdListContainerView.h:39

Arcane::impl::MeshItemSharedInfoList
Liste des ItemSharedInfo associés à un maillage.
Definition MeshItemInternalList.h:42

Arcane::mesh::DynamicMeshKindInfos
Infos de maillage pour un genre donné d'entité.
Definition DynamicMeshKindInfos.h:52

Arcane::mesh::FaceFamily
Famille de faces.
Definition FaceFamily.h:53

Arcane::mesh::IncrementalItemConnectivityBase
Classe de base pour les connectivités incrémentales item->item[].
Definition IncrementalItemConnectivity.h:100

Arcane::mesh::ItemFamily
Famille d'entités.
Definition ItemFamily.h:76

Arcane::mesh::MeshRefinement
Implémentation des algorithmes d'adaptation par raffinement de maillages non-structuré.
Definition MeshRefinement.h:57

Arcane::mesh::PolyhedralFamily
Definition PolyhedralMesh.cc:119

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

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

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

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

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

Arcane::Materials
Active toujours les traces dans les parties Arcane concernant les matériaux.
Definition RunCommandMaterialEnumerate.h:33

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

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

Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186

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

Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569

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

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

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

Arcane::ItemInternalConnectivityList::Container
Conteneur des vues pour les informations de connectivité d'une famille.
Definition ItemInternal.h:359

Arcane::ItemInternalConnectivityList::Int32View
Vue spécifique pour gérer les entités nulles.
Definition ItemInternal.h:115

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