ItemGroup.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroup.cc                                                (C) 2000-2025 */
/*                                                                           */
/* Mesh entity groups.                                                       */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#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)
{
  // If \a grp is null, it is replaced by the null group.
  // This is done (version 2.3) for compatibility reasons.
  // Eventually, this constructor will be explicit, and in that case, you will have to do:
  //   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());
}
 
// HANDLE CRASH 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->isContiguousLocalIds())
    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
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/