ItemTypes.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemTypes.h                                                 (C) 2000-2024 */
/*                                                                           */
/* Déclaration des types liés aux entités de maillage.                       */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ITEMTYPES_H
#define ARCANE_CORE_ITEMTYPES_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ArcaneTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
// A définir si on souhaiter ajouter un offset aux classes 'ItemVector' et
// 'ItemEnumerator'. Cela change la taille de ces structures et il ne faut
// donc recompiler code code utilisateur si on change ce '#define'.
#define ARCANE_HAS_OFFSET_FOR_ITEMVECTORVIEW
 
// A définir si on souhaite cacher les méthodes d'accès aux structures
// internes des connectivités. Pour l'instant (mi-2023) on ne le fait que
// pour les sources internes à Arcane mais ensuite il faudra le généraliser.
// (La macro ARCANE_FORCE_... est définie dans le CMakeLists.txt principal)
#ifdef ARCANE_FORCE_HIDE_ITEM_CONNECTIVITY_STRUCTURE
#define ARCANE_HIDE_ITEM_CONNECTIVITY_STRUCTURE
#endif
 
// A définir si on souhaite utiliser les classes spécifiques pour gérer
// les entités connectées (sinon on utilise ItemVectorView)
#define ARCANE_USE_SPECIFIC_ITEMCONNECTED
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Node;
class Cell;
class Edge;
class Face;
class Particle;
class DoF;
 
class Item;
class ItemWithNodes;
class ItemInternal;
class ItemBase;
class MutableItemBase;
namespace impl
{
using ItemBase = ::Arcane::ItemBase;
using MutableItemBase = ::Arcane::MutableItemBase;
template<int Extent = DynExtent> class ItemIndexedListView;
class ItemLocalIdListContainerView;
}
 
 
class IMesh;
class IPrimaryMesh;
class IItemFamily;
class IParticleFamily;
class IDoFFamily;
 
class ItemLocalId;
class ItemTypeId;
template<typename T> class ItemLocalIdT;
using NodeLocalId = ItemLocalIdT<Node>;
using EdgeLocalId = ItemLocalIdT<Edge>;
using FaceLocalId = ItemLocalIdT<Face>;
using CellLocalId = ItemLocalIdT<Cell>;
using ParticleLocalId = ItemLocalIdT<Particle>;
using DoFLocalId = ItemLocalIdT<DoF>;
class IndexedItemConnectivityViewBase;
class IndexedItemConnectivityViewBase2;
class IndexedItemConnectivityAccessor;
class ItemInternalConnectivityList;
class ItemInternalVectorView;
class ItemIndexArrayView;
class ItemLocalIdListView;
 
template<typename T> class ItemLocalIdListViewT;
template<typename ItemType> using ItemLocalIdViewT ARCANE_DEPRECATED_REASON("Use 'ItemLocalIdListView' type instead") = ItemLocalIdListViewT<ItemType>;
 
class ItemGroup;
class ItemGroupImpl;
template<typename T> class ItemGroupT;
 
class ItemPairGroup;
template<typename ItemKind,typename SubItemKind> class ItemPairGroupT;
 
class ItemVector;
template<typename T> class ItemVectorT;
 
class ItemVectorViewConstIterator;
template<typename ItemType>
class ItemVectorViewConstIteratorT;
 
class ItemConnectedListViewConstIterator;
template<typename ItemType>
class ItemConnectedListViewConstIteratorT;
 
// (Avril 2022) Fait un typedef de 'ItemLocalIdViewT' vers 'ItemLocalIdView'
// pour compatibilité avec l'existant. A supprimer dès que possible.
template <typename ItemType>
using ItemLocalIdView ARCANE_DEPRECATED_REASON("Use 'ItemLocalIdViewT' instead") = ItemLocalIdListViewT<ItemType>;
 
template<typename ItemType1,typename ItemType2>
class IndexedItemConnectivityViewT;
 
// (Avril 2022) Fait un typedef de 'IndexedItemConnectivityView' vers 'IndexedItemConnectivityViewT'
// pour compatibilité avec l'existant. A supprimer dès que possible.
template<typename ItemType1,typename ItemType2>
using IndexedItemConnectivityView ARCANE_DEPRECATED_REASON("Use 'IndexedItemConnectivityViewT' instead") = IndexedItemConnectivityViewT<ItemType1,ItemType2>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef ItemPairGroupT<Node,Node> NodeNodeGroup;
typedef ItemPairGroupT<Edge,Node> EdgeNodeGroup;
typedef ItemPairGroupT<Face,Node> FaceNodeGroup;
typedef ItemPairGroupT<Cell,Node> CellNodeGroup;

typedef ItemPairGroupT<Node,Face> NodeFaceGroup;
typedef ItemPairGroupT<Edge,Face> EdgeFaceGroup;
typedef ItemPairGroupT<Face,Face> FaceFaceGroup;
typedef ItemPairGroupT<Cell,Face> CellFaceGroup;

typedef ItemPairGroupT<Node,Cell> NodeCellGroup;
typedef ItemPairGroupT<Edge,Cell> EdgeCellGroup;
typedef ItemPairGroupT<Face,Cell> FaceCellGroup;
typedef ItemPairGroupT<Cell,Cell> CellCellGroup;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef ItemGroupT<Node> NodeGroup;
typedef ItemGroupT<Edge> EdgeGroup;
typedef ItemGroupT<Face> FaceGroup;
typedef ItemGroupT<Cell> CellGroup;
typedef ItemGroupT<Particle> ParticleGroup;
typedef ItemGroupT<DoF> DoFGroup;
class ItemInternalEnumerator;
class ItemEnumerator;
template<typename ItemType>
class ItemEnumeratorT;
 
class ItemConnectedEnumerator;
template<typename ItemType>
class ItemConnectedEnumeratorT;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class EnumeratorTraceInfo;
class SimdItemEnumeratorBase;
 
class ItemEnumeratorBase;
template<typename ItemType>
class ItemEnumeratorBaseT;
 
template<typename ItemType>
class ItemConnectedEnumeratorBaseT;
 
template<typename ItemType>
class SimdItemEnumeratorT;
template<typename ItemType>
class SimdItemT;

class ItemVectorView;
template<typename ItemType>
class ItemVectorViewT;

template<int Extent = DynExtent> class ItemConnectedListView;
template<typename ItemType, int Extent = DynExtent>
class ItemConnectedListViewT;

class ItemPairEnumerator;
template<typename ItemType,typename SubItemType>
class ItemPairEnumeratorT;

typedef ItemEnumeratorT<Node> NodeEnumerator;
typedef ItemEnumeratorT<Edge> EdgeEnumerator;

typedef ItemEnumeratorT<Face> FaceEnumerator;

typedef ItemEnumeratorT<Cell> CellEnumerator;

typedef ItemEnumeratorT<Particle> ParticleEnumerator;

typedef ItemEnumeratorT<DoF> DoFEnumerator;

typedef ItemVectorViewT<Node> NodeVectorView;
typedef ItemVectorViewT<Edge> EdgeVectorView;
typedef ItemVectorViewT<Face> FaceVectorView;
typedef ItemVectorViewT<Cell> CellVectorView;
typedef ItemVectorViewT<Particle> ParticleVectorView;

typedef ItemVectorViewT<DoF> DoFVectorView;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
using NodeConnectedListView = ItemConnectedListViewT<Node>;
using EdgeConnectedListView = ItemConnectedListViewT<Edge>;
using FaceConnectedListView = ItemConnectedListViewT<Face>;
using CellConnectedListView = ItemConnectedListViewT<Cell>;
using DoFConnectedListView = ItemConnectedListViewT<DoF>;
 
#ifdef ARCANE_USE_SPECIFIC_ITEMCONNECTED
using ItemConnectedListViewType = ItemConnectedListView<DynExtent>;
using NodeConnectedListViewType = NodeConnectedListView;
using EdgeConnectedListViewType = EdgeConnectedListView;
using FaceConnectedListViewType = FaceConnectedListView;
using CellConnectedListViewType = CellConnectedListView;
template<typename ItemType> using ItemConnectedListViewTypeT = ItemConnectedListViewT<ItemType>;
#else
using ItemConnectedListViewType = ItemVectorView;
using NodeConnectedListViewType = NodeVectorView;
using EdgeConnectedListViewType = EdgeVectorView;
using FaceConnectedListViewType = FaceVectorView;
using CellConnectedListViewType = CellVectorView;
template<typename ItemType> using ItemConnectedListViewTypeT = ItemVectorViewT<ItemType>;
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Collection<NodeGroup> NodeGroupCollection;
typedef Collection<EdgeGroup> EdgeGroupCollection;
typedef Collection<FaceGroup> FaceGroupCollection;
typedef Collection<CellGroup> CellGroupCollection;
typedef Collection<ParticleGroup> ParticleGroupCollection;
typedef Collection<DoFGroup> DoFGroupCollection;
 

typedef List<NodeGroup> NodeGroupList;
typedef List<EdgeGroup> EdgeGroupList;
typedef List<FaceGroup> FaceGroupList;
typedef List<CellGroup> CellGroupList;
typedef List<ParticleGroup> ParticleGroupList;
typedef List<DoFGroup> DoFGroupList;

typedef ItemLocalIdListViewT<Node> NodeLocalIdView;
using NodeLocalIdListView = ItemLocalIdListViewT<Node>;
typedef ItemLocalIdListViewT<Edge> EdgeLocalIdView;
using EdgeLocalIdListView = ItemLocalIdListViewT<Edge>;
typedef ItemLocalIdListViewT<Face> FaceLocalIdView;
using FaceLocalIdListView = ItemLocalIdListViewT<Face>;
typedef ItemLocalIdListViewT<Cell> CellLocalIdView;
using CellLocalIdListView = ItemLocalIdListViewT<Cell>;
typedef ItemLocalIdListViewT<Particle> ParticleLocalIdView;
using ParticleLocalIdListView = ItemLocalIdListViewT<Particle>;

typedef ItemLocalIdListViewT<DoF> DoFLocalIdView;
using DoFLocalIdListView = ItemLocalIdListViewT<DoF>;

typedef ConstArrayView<ItemInternal*> ItemInternalList;
 
typedef ConstArrayView<ItemInternal*> ItemInternalArrayView;
 
typedef ArrayView<ItemInternal*> ItemInternalMutableArrayView;
 
class IItemOperationByBasicType;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ItemInfoListView;
template <typename ItemType> class ItemInfoListViewT;
class NodeInfoListView;
class EdgeInfoListView;
class FaceInfoListView;
class CellInfoListView;
class ParticleInfoListView;
class DoFInfoListView;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ItemEnumeratorIndex;
template<typename ItemType>
class ItemEnumeratorIndexT;
using NodeEnumeratorIndex = ItemEnumeratorIndexT<Node>;
using EdgeEnumeratorIndex = ItemEnumeratorIndexT<Edge>;
using FaceEnumeratorIndex = ItemEnumeratorIndexT<Face>;
using CellEnumeratorIndex = ItemEnumeratorIndexT<Cell>;
using ParticleEnumeratorIndex = ItemEnumeratorIndexT<Particle>;
using DoFEnumeratorIndex = ItemEnumeratorIndexT<DoF>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
enum class InternalConnectivityPolicy
{
  Legacy,
  LegacyAndAllocAccessor,
  LegacyAndNew,
  NewAndLegacy,
  NewWithDependenciesAndLegacy,
  NewOnly,
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT InternalConnectivityInfo
{
 public:
  static constexpr bool hasLegacyConnectivity(InternalConnectivityPolicy) { return false; }
  static constexpr bool hasNewConnectivity(InternalConnectivityPolicy) { return true; }
  static constexpr bool useNewConnectivityAccessor(InternalConnectivityPolicy) { return true; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
typedef ItemVectorT<Node> NodeVector;
typedef ItemVectorT<Edge> EdgeVector;
typedef ItemVectorT<Face> FaceVector;
typedef ItemVectorT<Cell> CellVector;
typedef ItemVectorT<Particle> ParticleVector;
typedef ItemVectorT<DoF> DoFVector;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T>
class ItemTraitsT
{
 public:
  static eItemKind kind() { return IK_Unknown; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<Node>
{
 public:

  typedef ItemTraitsT<Node> ItemTraitsType;
  typedef Node ItemType;
  typedef NodeGroup ItemGroupType;
  typedef NodeLocalId LocalIdType;
 
 public:

  static eItemKind kind() { return IK_Node; }

  static const char* defaultFamilyName() { return "Node"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<Edge>
{
 public:

  typedef ItemTraitsT<Edge> ItemTraitsType;
  typedef Edge ItemType;
  typedef EdgeGroup ItemGroupType;
  typedef EdgeLocalId LocalIdType;
 
 public:

  static eItemKind kind() { return IK_Edge; }

  static const char* defaultFamilyName() { return "Edge"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<Face>
{
 public:

  typedef ItemTraitsT<Face> ItemTraitsType;
  typedef Face ItemType;
  typedef FaceGroup ItemGroupType;
  typedef FaceLocalId LocalIdType;
 
 public:

  static eItemKind kind() { return IK_Face; }

  static const char* defaultFamilyName() { return "Face"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<Cell>
{
 public:

  typedef ItemTraitsT<Cell> ItemTraitsType;
  typedef Cell ItemType;
  typedef CellGroup ItemGroupType;
  typedef CellLocalId LocalIdType;
 
 public:

  static eItemKind kind() { return IK_Cell; }

  static const char* defaultFamilyName() { return "Cell"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<Particle>
{
 public:

  typedef ItemTraitsT<Particle> ItemTraitsType;
  typedef Particle ItemType;
  typedef ParticleGroup ItemGroupType;
  typedef ParticleLocalId LocalIdType;
 
 public:

  static eItemKind kind() { return IK_Particle; }

  static const char* defaultFamilyName() { return nullptr; }
};
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class ItemTraitsT<DoF>
{
 public:

  typedef ItemTraitsT<DoF> ItemTraitsType;
  typedef DoF ItemType;
  typedef DoFGroup ItemGroupType;
  using LocalIdType = ItemLocalIdT<DoF>;
 
 public:

  static eItemKind kind() { return IK_DoF; }
 
  // NOTE: GG: devrait être nullptr car pas de défaut pour la famille de DoF ?
  static const char* defaultFamilyName() { return nullptr; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename ItemType>
class ItemLocalIdTraitsT
{
 public:

  using LocalIdType = typename ItemTraitsT<ItemType>::LocalIdType;
};

template<>
class ItemLocalIdTraitsT<Item>
{
 public:
  using LocalIdType = ItemLocalId;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif