CellFamily.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CellFamily.cc                                               (C) 2000-2025 */
/*                                                                           */
/* Cell Family.                                                              */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/mesh/CellFamily.h"
 
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/IMesh.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/ItemInternalEnumerator.h"
#include "arcane/core/Connectivity.h"
 
#include "arcane/mesh/NodeFamily.h"
#include "arcane/mesh/EdgeFamily.h"
#include "arcane/mesh/FaceFamily.h"
#include "arcane/mesh/CellMerger.h"
#include "arcane/mesh/IncrementalItemConnectivity.h"
#include "arcane/mesh/CompactIncrementalItemConnectivity.h"
#include "arcane/mesh/ItemConnectivitySelector.h"
#include "arcane/mesh/AbstractItemFamilyTopologyModifier.h"
#include "arcane/mesh/NewWithLegacyConnectivity.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class CellFamily::TopologyModifier
: public AbstractItemFamilyTopologyModifier
{
 public:
 
  TopologyModifier(CellFamily* f)
  : AbstractItemFamilyTopologyModifier(f)
  , m_true_family(f)
  {}
 
 public:
 
  void replaceNode(ItemLocalId item_lid, Integer index, ItemLocalId new_lid) override
  {
    m_true_family->replaceNode(item_lid, index, new_lid);
  }
  void replaceEdge(ItemLocalId item_lid, Integer index, ItemLocalId new_lid) override
  {
    m_true_family->replaceEdge(item_lid, index, new_lid);
  }
  void replaceFace(ItemLocalId item_lid, Integer index, ItemLocalId new_lid) override
  {
    m_true_family->replaceFace(item_lid, index, new_lid);
  }
  void replaceHParent(ItemLocalId item_lid, Integer index, ItemLocalId new_lid) override
  {
    m_true_family->replaceHParent(item_lid, index, new_lid);
  }
  void replaceHChild(ItemLocalId item_lid, Integer index, ItemLocalId new_lid) override
  {
    m_true_family->replaceHChild(item_lid, index, new_lid);
  }
 
 private:
 
  CellFamily* m_true_family;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellFamily::
CellFamily(IMesh* mesh, const String& name)
: ItemFamily(mesh, IK_Cell, name)
, m_node_prealloc(0)
, m_edge_prealloc(0)
, m_face_prealloc(0)
, m_mesh_connectivity(0)
, m_node_family(nullptr)
, m_edge_family(nullptr)
, m_face_family(nullptr)
, m_node_connectivity(nullptr)
, m_edge_connectivity(nullptr)
, m_face_connectivity(nullptr)
, m_hparent_connectivity(nullptr)
{
  _setTopologyModifier(new TopologyModifier(this));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellFamily::
~CellFamily()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
build()
{
  ItemFamily::build();
 
  m_node_family = ARCANE_CHECK_POINTER(dynamic_cast<NodeFamily*>(m_mesh->nodeFamily()));
  m_edge_family = ARCANE_CHECK_POINTER(dynamic_cast<EdgeFamily*>(m_mesh->edgeFamily()));
  m_face_family = ARCANE_CHECK_POINTER(dynamic_cast<FaceFamily*>(m_mesh->faceFamily()));
 
  IItemFamilyNetwork* network = m_mesh->itemFamilyNetwork();
  if (m_mesh->useMeshItemFamilyDependencies()) { // temporary to fill legacy, even with family dependencies
    auto* nc = network->getConnectivity(this, m_node_family, connectivityName(this, m_node_family));
    using NodeNetwork = NewWithLegacyConnectivityType<CellFamily, NodeFamily>::type;
    m_node_connectivity = ARCANE_CHECK_POINTER(dynamic_cast<NodeNetwork*>(nc));
    using EdgeNetwork = NewWithLegacyConnectivityType<CellFamily, EdgeFamily>::type;
    auto* ec = network->getConnectivity(this, m_edge_family, connectivityName(this, m_edge_family));
    m_edge_connectivity = ARCANE_CHECK_POINTER(dynamic_cast<EdgeNetwork*>(ec));
    using FaceNetwork = NewWithLegacyConnectivityType<CellFamily, FaceFamily>::type;
    auto* fc = network->getConnectivity(this, m_face_family, connectivityName(this, m_face_family));
    m_face_connectivity = ARCANE_CHECK_POINTER(dynamic_cast<FaceNetwork*>(fc));
  }
  else {
    m_node_connectivity = new NodeConnectivity(this, m_node_family, "CellNode");
    m_edge_connectivity = new EdgeConnectivity(this, m_edge_family, "CellEdge");
    m_face_connectivity = new FaceConnectivity(this, m_face_family, "CellFace");
  }
  m_hparent_connectivity = new HParentConnectivity(this, this, "HParentCell");
  m_hchild_connectivity = new HChildConnectivity(this, this, "HChildCell");
 
  _addConnectivitySelector(m_node_connectivity);
  _addConnectivitySelector(m_edge_connectivity);
  _addConnectivitySelector(m_face_connectivity);
  _addConnectivitySelector(m_hparent_connectivity);
  _addConnectivitySelector(m_hchild_connectivity);
 
  _buildConnectivitySelectors();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline void CellFamily::
_createOne(ItemInternal* item, Int64 uid, ItemTypeInfo* type)
{
  ItemLocalId item_lid(item);
  m_item_internal_list->cells = _itemsInternal();
  _allocateInfos(item, uid, type);
  auto nc = m_node_connectivity->trueCustomConnectivity();
  nc->addConnectedItems(item_lid, type->nbLocalNode());
  if (m_edge_prealloc != 0) {
    auto ec = m_edge_connectivity->trueCustomConnectivity();
    ec->addConnectedItems(item_lid, type->nbLocalEdge());
  }
  auto fc = m_face_connectivity->trueCustomConnectivity();
  fc->addConnectedItems(item_lid, type->nbLocalFace());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline void CellFamily::
_createOne(ItemInternal* item, Int64 uid, ItemTypeId type_id)
{
  _createOne(item, uid, _itemTypeMng()->typeFromId(type_id));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Item CellFamily::
allocOne(Int64 uid, ItemTypeId type_id, MeshInfos& mesh_info)
{
  ++mesh_info.nbCell();
  return allocOne(uid, type_id);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Item CellFamily::
findOrAllocOne(Int64 uid, ItemTypeId type_id, MeshInfos& mesh_info, bool& is_alloc)
{
  auto cell = findOrAllocOne(uid, type_id, is_alloc);
  if (is_alloc)
    ++mesh_info.nbCell();
  return cell;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Cell CellFamily::
allocOne(Int64 uid, ItemTypeId type_id)
{
  ItemInternal* item = _allocOne(uid);
  _createOne(item, uid, type_id);
  return item;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Cell CellFamily::
findOrAllocOne(Int64 uid, ItemTypeId type_id, bool& is_alloc)
{
  return findOrAllocOne(uid, _itemTypeMng()->typeFromId(type_id), is_alloc);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemInternal* CellFamily::
allocOne(Int64 uid, ItemTypeInfo* type)
{
  ItemInternal* item = _allocOne(uid);
  _createOne(item, uid, type);
  return item;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemInternal* CellFamily::
findOrAllocOne(Int64 uid, ItemTypeInfo* type, bool& is_alloc)
{
  // ARCANE_ASSERT((type->typeId() != IT_Line2),("Bad new 1D cell uid=%ld", uid)); // Assertion OK, but expensive ?
  ItemInternal* item = _findOrAllocOne(uid, is_alloc);
  if (is_alloc)
    _createOne(item, uid, type);
  return item;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IncrementalItemConnectivity* CellFamily::
nodeConnectivity() const
{
  return m_node_connectivity->trueCustomConnectivity();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IncrementalItemConnectivity* CellFamily::
edgeConnectivity() const
{
  return m_edge_connectivity->trueCustomConnectivity();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IncrementalItemConnectivity* CellFamily::
faceConnectivity() const
{
  return m_face_connectivity->trueCustomConnectivity();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
allocateItemsBulk(Int64ConstArrayView uids, ItemTypeInfo* type, Int32 owner, Int32ArrayView lids)
{
  m_item_internal_list->cells = _itemsInternal();
  _allocateInfosBulk(uids, type, owner, lids);
  m_item_internal_list->cells = _itemsInternal();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
preAllocate(Integer nb_item)
{
  this->_preAllocate(nb_item, true);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
computeSynchronizeInfos()
{
  debug() << "Creating the list of ghost cells";
  ItemFamily::computeSynchronizeInfos();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_removeSubItems(Cell cell)
{
  ItemLocalId cell_lid(cell.localId());
 
  // Must first remove faces, then edges, then nodes
  // see notes on _removeOne in the families.
  // NOTE GG: it is normally no longer necessary to do this in a fixed order
  // because these methods do not delete the entities. Destruction
  // happens when calling removeNotConnectedSubItems().
  for (Face face : cell.faces())
    m_face_family->removeCellFromFace(face, cell_lid);
  for (Edge edge : cell.edges())
    m_edge_family->removeCellFromEdge(edge, cell_lid);
  for (Node node : cell.nodes())
    m_node_family->removeCellFromNode(node, cell_lid);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
removeCell(Cell icell)
{
#ifdef ARCANE_CHECK
  _checkValidItem(icell);
  if (icell.itemBase().isSuppressed())
    ARCANE_FATAL("Cell '{0}' is already removed", icell.uniqueId());
#endif
  // TODO: remove connected faces and edges.
  _removeSubItems(icell);
  _removeNotConnectedSubItems(icell);
  if (icell.level() > 0) {
    _removeParentCellToCell(icell);
    Cell parent_cell = icell.hParent();
    _removeChildCellToCell(parent_cell, icell);
  }
  _removeOne(icell);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
removeCells(ConstArrayView<Int32> cells_local_id)
{
  CellLocalIdToCellConverter cells(this);
  for (Int32 lid : cells_local_id)
    removeCell(cells[lid]);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
detachCell(Cell icell)
{
#ifdef ARCANE_CHECK
  _checkValidItem(icell);
  if (icell.itemBase().isSuppressed())
    ARCANE_FATAL("Cell '{0}' is already removed", icell.uniqueId());
#endif /* ARCANE_CHECK */
 
  _removeSubItems(icell);
  if (icell.level() > 0) {
    _removeParentCellToCell(icell);
    Cell parent_cell = icell.hParent();
    _removeChildCellToCell(parent_cell, icell);
  }
  _detachOne(icell);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
detachCells2(Int32ConstArrayView cells_local_id)
{
  // Implemented in ItemFamily. Even if only cells are detached, the implementation
  // is not CellFamily specific, thx to ItemFamilyNetwork
  _detachCells2(cells_local_id);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void CellFamily::
_removeNotConnectedSubItems(Cell cell)
{
  // The order (faces, then edges then nodes) is important.
  // Do not change.
 
  // Remove faces from the cell that are no longer connected
  for (Face face : cell.faces())
    m_face_family->removeFaceIfNotConnected(face);
 
  // Remove edges from the cell that are no longer connected
  for (Edge edge : cell.edges())
    m_edge_family->removeEdgeIfNotConnected(edge);
 
  // remove nodes from the cell that are no longer connected
  for (Node node : cell.nodes())
    m_node_family->removeNodeIfNotConnected(node);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
removeDetachedCell(Cell cell)
{
  _removeNotConnectedSubItems(cell);
 
  // remove the cell
  _removeDetachedOne(cell);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
internalRemoveItems(Int32ConstArrayView local_ids, bool keep_ghost)
{
  ARCANE_UNUSED(keep_ghost);
  for (Integer i = 0, is = local_ids.size(); i < is; ++i) {
    removeCell(m_item_internal_list->cells[local_ids[i]]);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void CellFamily::
replaceNode(ItemLocalId cell, Integer index, ItemLocalId node)
{
  m_node_connectivity->replaceItem(cell, index, node);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void CellFamily::
replaceEdge(ItemLocalId cell, Integer index, ItemLocalId edge)
{
  m_edge_connectivity->replaceItem(cell, index, edge);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void CellFamily::
replaceFace(ItemLocalId cell, Integer index, ItemLocalId face)
{
  m_face_connectivity->replaceItem(cell, index, face);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
replaceHChild(ItemLocalId cell, Integer index, ItemLocalId child_cell)
{
  m_hchild_connectivity->replaceItem(cell, index, child_cell);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
replaceHParent(ItemLocalId cell, Integer index, ItemLocalId parent_cell)
{
  m_hparent_connectivity->replaceItem(cell, index, parent_cell);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
setConnectivity(const Integer c)
{
  m_mesh_connectivity = c;
  m_node_prealloc = Connectivity::getPrealloc(m_mesh_connectivity, IK_Cell, IK_Node);
  m_node_connectivity->setPreAllocatedSize(m_node_prealloc);
  // Edges only exist in dimension 3.
  if (mesh()->dimension() == 3) {
    Integer edge_prealloc = Connectivity::getPrealloc(m_mesh_connectivity, IK_Cell, IK_Edge);
    m_edge_connectivity->setPreAllocatedSize(edge_prealloc);
    if (Connectivity::hasConnectivity(m_mesh_connectivity, Connectivity::CT_HasEdge))
      m_edge_prealloc = edge_prealloc;
  }
  m_face_prealloc = Connectivity::getPrealloc(m_mesh_connectivity, IK_Cell, IK_Face);
  m_face_connectivity->setPreAllocatedSize(m_face_prealloc);
  debug() << "Family " << name() << " prealloc "
          << m_node_prealloc << " by node, "
          << m_edge_prealloc << " by edge, "
          << m_face_prealloc << " by face.";
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_addParentCellToCell(Cell cell, Cell parent_cell)
{
  m_hparent_connectivity->addConnectedItem(ItemLocalId(cell), ItemLocalId(parent_cell));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_addChildCellToCell2(Cell iparent_cell, Cell child_cell)
{
  m_hchild_connectivity->addConnectedItem(ItemLocalId(iparent_cell), ItemLocalId(child_cell));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_addChildCellToCell(Cell iparent_cell, Integer position, Cell child_cell)
{
  Cell parent_cell(iparent_cell);
  // NOTE GG: The old method below in comment seems
  // to only work if \a position corresponds to parent_cell->nbHChildren().
  // And in this case, it is not necessary to make 2 calls.
  // m_hchild_connectivity->addConnectedItem(parent_cell,ItemLocalId(NULL_ITEM_LOCAL_ID));
  Int32 nb_connected = m_hchild_connectivity->trueCustomConnectivity()->nbConnectedItem(parent_cell);
  for (Int32 i = nb_connected; i < (position + 1); ++i)
    m_hchild_connectivity->addConnectedItem(parent_cell, ItemLocalId(NULL_ITEM_LOCAL_ID));
  auto x = _topologyModifier();
  x->replaceHChild(ItemLocalId(iparent_cell), position, child_cell);
  parent_cell.mutableItemBase().addFlags(ItemFlags::II_Inactive);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_addChildrenCellsToCell(Cell parent_cell, Int32ConstArrayView children_cells_lid)
{
  Integer nb_children = children_cells_lid.size();
  auto c = m_hchild_connectivity->trueCustomConnectivity();
  if (c) {
    ItemLocalId item_lid(parent_cell);
    c->addConnectedItems(item_lid, nb_children);
  }
  _updateSharedInfo();
 
  auto x = _topologyModifier();
  for (Integer i = 0; i < nb_children; ++i)
    x->replaceHChild(ItemLocalId(parent_cell), i, ItemLocalId(children_cells_lid[i]));
 
  parent_cell.mutableItemBase().addFlags(ItemFlags::II_Inactive);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_removeParentCellToCell(Cell cell)
{
  m_hparent_connectivity->removeConnectedItems(ItemLocalId(cell));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_removeChildCellToCell(Cell parent_cell, Cell cell)
{
  m_hchild_connectivity->removeConnectedItem(ItemLocalId(parent_cell), ItemLocalId(cell));
  parent_cell.mutableItemBase().removeFlags(ItemFlags::II_Inactive);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CellFamily::
_removeChildrenCellsToCell(Cell parent_cell)
{
  m_hchild_connectivity->removeConnectedItems(ItemLocalId(parent_cell));
  parent_cell.mutableItemBase().removeFlags(ItemFlags::II_Inactive);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/