d4/dba/ItemGroup_8cc_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

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

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

/* ItemGroup.cc                                                (C) 2000-2025 */

/*                                                                           */

/* Groupes d'entités du maillage.                                            */

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

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


#include "arcane/core/ItemGroup.h"


#include "arcane/utils/String.h"

#include "arcane/utils/ArgumentException.h"


#include "arcane/core/IItemFamily.h"

#include "arcane/core/IMesh.h"

#include "arcane/core/ICaseMng.h"

#include "arcane/core/CaseOptionBase.h"

#include "arcane/core/ICaseOptionList.h"

#include "arcane/core/MeshHandle.h"

#include "arcane/core/internal/ItemGroupInternal.h"


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

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


namespace Arcane

{


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

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

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

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


ItemGroup::

ItemGroup(ItemGroupImpl* grp)

: m_impl(grp)

{

  // Si \a grp est nul, le remplace par le groupe nul.

  // Cela est fait (version 2.3) pour des raisons de compatibilité.

  // A terme, ce constructeur sera explicite et dans ce cas il

  // faudra faire:

  //   ARCANE_CHECK_POINTER(grp);

  if (!grp){

    std::cerr << "Creating group with null pointer is not allowed\n";

    m_impl = ItemGroupImpl::checkSharedNull();

  }

}


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

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


ItemGroup::

ItemGroup()

: m_impl(ItemGroupImpl::checkSharedNull())

{

}


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

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


bool ItemGroup::

isOwn() const

{

  if (null())

    return true;


  return m_impl->isOwn();

}


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

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


void ItemGroup::

setOwn(bool v)

{

  if (!null())

    m_impl->setOwn(v);

}


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

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


ItemGroup ItemGroup::

own() const

{

  if (null() || isOwn())

    return (*this);

  m_impl->checkNeedUpdate();

  return ItemGroup(m_impl->ownGroup());

}


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

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


// group of items owned by the subdomain

ItemGroup ItemGroup::

ghost() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return ItemGroup(m_impl->ghostGroup());

}


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

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


// Items in the group lying on the boundary between two subdomains

// Implemented for faces only

ItemGroup ItemGroup::

interface() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return ItemGroup(m_impl->interfaceGroup());

}


// GERER PLANTAGE SORTED

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

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


NodeGroup ItemGroup::

nodeGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return NodeGroup(m_impl->nodeGroup());

}


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

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


EdgeGroup ItemGroup::

edgeGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return EdgeGroup(m_impl->edgeGroup());

}


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

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


FaceGroup ItemGroup::

faceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->faceGroup());

}


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

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


CellGroup ItemGroup::

cellGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return CellGroup(m_impl->cellGroup());

}


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

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


FaceGroup ItemGroup::

innerFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->innerFaceGroup());

}


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

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


FaceGroup ItemGroup::

outerFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->outerFaceGroup());

}


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

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

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

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


CellGroup ItemGroup::

activeCellGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return CellGroup(m_impl->activeCellGroup());

}


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

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


CellGroup ItemGroup::

ownActiveCellGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return CellGroup(m_impl->ownActiveCellGroup());

}


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

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


CellGroup ItemGroup::

levelCellGroup(const Integer& level) const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return CellGroup(m_impl->levelCellGroup(level));

}


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

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


CellGroup ItemGroup::

ownLevelCellGroup(const Integer& level) const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return CellGroup(m_impl->ownLevelCellGroup(level));

}


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

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


FaceGroup ItemGroup::

activeFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->activeFaceGroup());

}


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

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


FaceGroup ItemGroup::

ownActiveFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->ownActiveFaceGroup());

}


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

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


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

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


FaceGroup ItemGroup::

innerActiveFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->innerActiveFaceGroup());

}


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

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


FaceGroup ItemGroup::

outerActiveFaceGroup() const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return FaceGroup(m_impl->outerActiveFaceGroup());

}


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

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


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

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


ItemGroup ItemGroup::

createSubGroup(const String & suffix, IItemFamily * family, ItemGroupComputeFunctor * functor) const

{

  if (null())

    return ItemGroup();

  m_impl->checkNeedUpdate();

  return ItemGroup(m_impl->createSubGroup(suffix,family,functor));

}


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

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


ItemGroup ItemGroup::

findSubGroup(const String & suffix) const

{

  if (null())

    return ItemGroup();

  return ItemGroup(m_impl->findSubGroup(suffix));

}


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

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


void ItemGroup::

clear()

{

  m_impl->clear();

}


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

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


void ItemGroup::

addItems(Int32ConstArrayView items_local_id,bool check_if_present)

{

  if (null())

    throw ArgumentException(A_FUNCINFO,"Can not addItems() to null group");

  if (isAllItems())

    throw ArgumentException(A_FUNCINFO,"Can not addItems() to all-items group");

  m_impl->_checkNeedUpdateNoPadding();

  m_impl->addItems(items_local_id,check_if_present);

}


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

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


void ItemGroup::

removeItems(Int32ConstArrayView items_local_id,bool check_if_present)

{

  if (null())

    throw ArgumentException(A_FUNCINFO,"Can not removeItems() to null group");

  if (isAllItems())

    throw ArgumentException(A_FUNCINFO,"Can not removeItems() to all-items group");

  m_impl->_checkNeedUpdateNoPadding();

  m_impl->removeItems(items_local_id,check_if_present);

}


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

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


void ItemGroup::

setItems(Int32ConstArrayView items_local_id)

{

  if (null())

    throw ArgumentException(A_FUNCINFO,"Can not setItems() to null group");

  m_impl->setItems(items_local_id);

}


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

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


void ItemGroup::

setItems(Int32ConstArrayView items_local_id,bool do_sort)

{

  if (null())

    throw ArgumentException(A_FUNCINFO,"Can not setItems() to null group");

  m_impl->setItems(items_local_id,do_sort);

}


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

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


void ItemGroup::

checkValid()

{

  m_impl->checkValid();

}


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

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


void ItemGroup::

applyOperation(IItemOperationByBasicType* operation) const

{

  if (null())

    return;

  m_impl->checkNeedUpdate();

  m_impl->applyOperation(operation);

}


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

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


ItemEnumerator ItemGroup::

enumerator() const

{

  if (null())

    return ItemEnumerator();

  m_impl->_checkNeedUpdateNoPadding();

  return ItemEnumerator(m_impl->itemInfoListView(),m_impl->itemsLocalId(),m_impl.get());

}


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

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


ItemEnumerator ItemGroup::

_simdEnumerator() const

{

  if (null())

    return ItemEnumerator();

  m_impl->_checkNeedUpdateWithPadding();

  return ItemEnumerator(m_impl->itemInfoListView(),m_impl->itemsLocalId(),m_impl.get());

}


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

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


ItemVectorView ItemGroup::

_view(bool do_padding) const

{

  if (null())

    return ItemVectorView();

  m_impl->_checkNeedUpdate(do_padding);

  Int32 flags = 0;

  if (m_impl->isContigousLocalIds())

    flags |= ItemIndexArrayView::F_Contigous;

  // TODO: gérer l'offset

  return ItemVectorView(m_impl->itemFamily(),ItemIndexArrayView(m_impl->itemsLocalId(),0,flags));

}


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

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


ItemVectorView ItemGroup::

view() const

{

  return _view(true);

}


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

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


ItemVectorView ItemGroup::

_paddedView() const

{

  return _view(true);

}


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

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


ItemVectorView ItemGroup::

_unpaddedView() const

{

  return _view(false);

}


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

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


bool ItemGroup::

isAllItems() const

{

  return m_impl->isAllItems();

}


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

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


IVariableSynchronizer* ItemGroup::

synchronizer() const

{

  return m_impl->synchronizer();

}


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

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


bool ItemGroup::

isAutoComputed() const

{

  return m_impl->hasComputeFunctor();

}


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

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


bool ItemGroup::

hasSynchronizer() const

{

  return m_impl->hasSynchronizer();

}


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

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


ItemGroupImplInternal* ItemGroup::

_internalApi() const

{

  return m_impl->_internalApi();

}


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

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


bool ItemGroup::

checkIsSorted() const

{

  m_impl->_checkNeedUpdate(false);

  return m_impl->checkIsSorted();

}


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

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


void ItemGroup::

incrementTimestamp() const

{

  m_impl->m_p->updateTimestamp();

}


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

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


extern ARCANE_CORE_EXPORT bool

_caseOptionConvert(const CaseOptionBase& co,const String& name,ItemGroup& obj)

{

  IMesh* mesh = co.parentOptionList()->meshHandle().mesh();

  obj = mesh->findGroup(name);

  return obj.null();

}


extern ARCANE_CORE_EXPORT bool

_caseOptionConvert(const CaseOptionBase& co,const String& name,NodeGroup& obj)

{

  IMesh* mesh = co.parentOptionList()->meshHandle().mesh();

  obj = mesh->nodeFamily()->findGroup(name);

  return obj.null();

}


extern ARCANE_CORE_EXPORT bool

_caseOptionConvert(const CaseOptionBase& co,const String& name,EdgeGroup& obj)

{

  IMesh* mesh = co.parentOptionList()->meshHandle().mesh();

  obj = mesh->edgeFamily()->findGroup(name);

  return obj.null();

}


extern ARCANE_CORE_EXPORT bool

_caseOptionConvert(const CaseOptionBase& co,const String& name,FaceGroup& obj)

{

  IMesh* mesh = co.parentOptionList()->meshHandle().mesh();

  obj = mesh->faceFamily()->findGroup(name);

  return obj.null();

}


extern ARCANE_CORE_EXPORT bool

_caseOptionConvert(const CaseOptionBase& co,const String& name,CellGroup& obj)

{

  IMesh* mesh = co.parentOptionList()->meshHandle().mesh();

  obj = mesh->cellFamily()->findGroup(name);

  return obj.null();

}


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

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


} // End namespace Arcane


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

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

Arcane::ArgumentException
Exception lorsqu'un argument est invalide.
Definition arccore/src/base/arccore/base/ArgumentException.h:33

Arcane::CaseOptionBase
Classe de base d'une option du jeu de donnée.
Definition CaseOptionBase.h:51

Arcane::CaseOptionBase::parentOptionList
ICaseOptionList * parentOptionList() const
OptionList parent.
Definition CaseOptionBase.cc:122

Arcane::ICaseOptionList::meshHandle
virtual MeshHandle meshHandle() const =0
Handle du maillage associé

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

Arcane::IItemOperationByBasicType
Interface d'un opérateur sur des entités rangées par type.
Definition IItemOperationByBasicType.h:43

Arcane::IMesh
Definition IMesh.h:59

Arcane::IVariableSynchronizer
Interface d'un service de synchronisation de variable.
Definition IVariableSynchronizer.h:42

Arcane::ItemEnumerator
Enumérateur sur une liste d'entités.
Definition ItemEnumerator.h:58

Arcane::ItemGroupComputeFunctor
Fonctor pour le calcul des éléments d'un groupe.
Definition ItemFunctor.h:155

Arcane::ItemGroupImplInternal
API interne à Arcane de ItemGroupImpl.
Definition ItemGroupImplInternal.h:33

Arcane::ItemGroupImpl
Implémentation d'un groupe d'entités de maillage.
Definition ItemGroupImpl.h:73

Arcane::ItemGroup
Groupe d'entités de maillage.
Definition ItemGroup.h:49

Arcane::ItemGroup::enumerator
ItemEnumerator enumerator() const
Enumérateur sur les entités du groupe.
Definition ItemGroup.cc:543

Arcane::ItemGroup::checkIsSorted
bool checkIsSorted() const
Vérifie et retourne si le groupe est trié par uniqueId() croissants.
Definition ItemGroup.cc:655

Arcane::ItemGroup::clear
void clear()
Supprime les entités du groupe.
Definition ItemGroup.cc:429

Arcane::ItemGroup::findSubGroup
ItemGroup findSubGroup(const String &suffix) const
Accès à un sous-groupe.
Definition ItemGroup.cc:418

Arcane::ItemGroup::createSubGroup
ItemGroup createSubGroup(const String &suffix, IItemFamily *family, ItemGroupComputeFunctor *functor) const
Crée un sous-groupe calculé
Definition ItemGroup.cc:406

Arcane::ItemGroup::synchronizer
IVariableSynchronizer * synchronizer() const
Synchronizer du groupe.
Definition ItemGroup.cc:619

Arcane::ItemGroup::nodeGroup
NodeGroup nodeGroup() const
Groupe des noeuds des éléments de ce groupe.
Definition ItemGroup.cc:230

Arcane::ItemGroup::isAutoComputed
bool isAutoComputed() const
Vrai s'il s'agit d'un groupe calculé automatiquement.
Definition ItemGroup.cc:628

Arcane::ItemGroup::faceGroup
FaceGroup faceGroup() const
Groupe des faces des éléments de ce groupe.
Definition ItemGroup.cc:254

Arcane::ItemGroup::incrementTimestamp
void incrementTimestamp() const
Incrément le temps de dernière modification du groupe.
Definition ItemGroup.cc:665

Arcane::ItemGroup::isOwn
bool isOwn() const
Retourne si le groupe contient uniquement des éléments propres au sous-domaine.
Definition ItemGroup.cc:158

Arcane::ItemGroup::removeItems
void removeItems(Int32ConstArrayView items_local_id, bool check_if_present=true)
Supprime des entités.
Definition ItemGroup.cc:468

Arcane::ItemGroup::activeFaceGroup
FaceGroup activeFaceGroup() const
Groupe des faces actives.
Definition ItemGroup.cc:352

Arcane::ItemGroup::innerActiveFaceGroup
FaceGroup innerActiveFaceGroup() const
Groupe des faces internes des éléments de ce groupe.
Definition ItemGroup.cc:379

Arcane::ItemGroup::view
ItemVectorView view() const
Vue sur les entités du groupe.
Definition ItemGroup.cc:583

Arcane::ItemGroup::setItems
void setItems(Int32ConstArrayView items_local_id)
Positionne les entités du groupe.
Definition ItemGroup.cc:489

Arcane::ItemGroup::ownActiveFaceGroup
FaceGroup ownActiveFaceGroup() const
Groupe des faces actives propres au domaine des éléments de ce groupe.
Definition ItemGroup.cc:364

Arcane::ItemGroup::cellGroup
CellGroup cellGroup() const
Groupe des mailles des éléments de ce groupe.
Definition ItemGroup.cc:266

Arcane::ItemGroup::applyOperation
void applyOperation(IItemOperationByBasicType *operation) const
Applique l'opération operation sur les entités du groupe.
Definition ItemGroup.cc:531

Arcane::ItemGroup::m_impl
AutoRefT< ItemGroupImpl > m_impl
Représentation interne du groupe.
Definition ItemGroup.h:355

Arcane::ItemGroup::levelCellGroup
CellGroup levelCellGroup(const Integer &level) const
Groupe des mailles de niveau l des éléments de ce groupe.
Definition ItemGroup.cc:329

Arcane::ItemGroup::addItems
void addItems(Int32ConstArrayView items_local_id, bool check_if_present=true)
Ajoute des entités.
Definition ItemGroup.cc:446

Arcane::ItemGroup::innerFaceGroup
FaceGroup innerFaceGroup() const
Groupe des faces internes des éléments de ce groupe.
Definition ItemGroup.cc:278

Arcane::ItemGroup::_internalApi
ItemGroupImplInternal * _internalApi() const
API interne à Arcane.
Definition ItemGroup.cc:646

Arcane::ItemGroup::_simdEnumerator
ItemEnumerator _simdEnumerator() const
Enumérateur sur les entités du groupe pour la vectorisation.
Definition ItemGroup.cc:555

Arcane::ItemGroup::_paddedView
ItemVectorView _paddedView() const
Vue sur les entités du groupe avec padding pour la vectorisation.
Definition ItemGroup.cc:592

Arcane::ItemGroup::hasSynchronizer
bool hasSynchronizer() const
Indique si le groupe possède un synchroniser actif.
Definition ItemGroup.cc:637

Arcane::ItemGroup::isAllItems
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:610

Arcane::ItemGroup::_unpaddedView
ItemVectorView _unpaddedView() const
Vue sur les entités du groupe sans padding pour la vectorisation.
Definition ItemGroup.cc:601

Arcane::ItemGroup::edgeGroup
EdgeGroup edgeGroup() const
Groupe des arêtes des éléments de ce groupe.
Definition ItemGroup.cc:242

Arcane::ItemGroup::ownActiveCellGroup
CellGroup ownActiveCellGroup() const
Groupe des mailles propres actives des éléments de ce groupe.
Definition ItemGroup.cc:317

Arcane::ItemGroup::checkValid
void checkValid()
Vérification interne de la validité du groupe.
Definition ItemGroup.cc:522

Arcane::ItemGroup::null
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70

Arcane::ItemGroup::setOwn
void setOwn(bool v)
Positionne la propriété de groupe local ou non.
Definition ItemGroup.cc:170

Arcane::ItemGroup::ownLevelCellGroup
CellGroup ownLevelCellGroup(const Integer &level) const
Groupe des mailles propres de niveau l des éléments de ce groupe.
Definition ItemGroup.cc:341

Arcane::ItemGroup::ItemGroup
ItemGroup()
Construit un groupe nul.
Definition ItemGroup.cc:149

Arcane::ItemGroup::outerActiveFaceGroup
FaceGroup outerActiveFaceGroup() const
Groupe des faces externes actives des éléments de ce groupe.
Definition ItemGroup.cc:391

Arcane::ItemGroup::own
ItemGroup own() const
Groupe équivalent à celui-ci mais contenant uniquement les éléments propres au sous-domaine.
Definition ItemGroup.cc:190

Arcane::ItemGroup::activeCellGroup
CellGroup activeCellGroup() const
AMR.
Definition ItemGroup.cc:305

Arcane::ItemGroup::outerFaceGroup
FaceGroup outerFaceGroup() const
Groupe des faces externes des éléments de ce groupe.
Definition ItemGroup.cc:290

Arcane::ItemIndexArrayView
Vue sur un tableau d'index (localIds()) d'entités.
Definition ItemIndexArrayView.h:40

Arcane::ItemIndexArrayView::F_Contigous
@ F_Contigous
Les numéros locaux sont contigüs.
Definition ItemIndexArrayView.h:55

Arcane::ItemVectorView
Vue sur un vecteur d'entités.
Definition ItemVectorView.h:227

Arcane::MeshHandle::mesh
IMesh * mesh() const
Maillage associé.
Definition MeshHandle.cc:133

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

Arcane::CellGroup
ItemGroupT< Cell > CellGroup
Groupe de mailles.
Definition ItemTypes.h:183

Arcane::FaceGroup
ItemGroupT< Face > FaceGroup
Groupe de faces.
Definition ItemTypes.h:178

Arcane::EdgeGroup
ItemGroupT< Edge > EdgeGroup
Groupe d'arêtes.
Definition ItemTypes.h:173

Arcane::NodeGroup
ItemGroupT< Node > NodeGroup
Groupe de noeuds.
Definition ItemTypes.h:167

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::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::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184