FullItemInfo.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* FullItemInfo.h                                              (C) 2000-2021 */
/*                                                                           */
/* Serialization information for a mesh.                                     */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/mesh/FullItemInfo.h"
 
#include "arcane/ISerializer.h"
#include "arcane/ItemInternal.h"
#include "arcane/ItemInternalEnumerator.h"
 
#include "arcane/mesh/DynamicMesh.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FullCellInfo::
FullCellInfo(Int64ConstArrayView cells_infos, Integer cell_index,
             ItemTypeMng* itm, Integer parent_info,
             bool has_edge, bool has_amr, bool with_flags)
: m_nb_node(0)
, m_nb_edge(0)
, m_nb_face(0)
, m_first_edge(0)
, m_first_face(0)
, m_memory_used(0)
, m_type(0)
, m_first_parent_node(0)
, m_first_parent_edge(0)
, m_first_parent_face(0)
, m_first_parent_cell(0)
, m_parent_info(parent_info)
, m_has_edge(has_edge)
, m_first_hParent_cell(0)
, m_has_amr(has_amr)
, m_with_flags(with_flags)
{
  Integer item_type_id = (Integer)cells_infos[cell_index];
  ItemTypeInfo* it = itm->typeFromId(item_type_id);
  m_type = it;
  _setInternalInfos();
  m_infos = Int64ConstArrayView(m_memory_used, &cells_infos[cell_index]);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FullCellInfo::
print(std::ostream& o) const
{
  o << "Cell uid=" << uniqueId()
    << " nb_node=" << nbNode()
    << " nb_edge=" << nbEdge()
    << " nb_face=" << nbFace()
    << ' ';
  for (Integer z = 0, zs = nbNode(); z < zs; ++z)
    o << " N" << z << "=" << nodeUniqueId(z);
  for (Integer z = 0, zs = nbEdge(); z < zs; ++z)
    o << " E" << z << "=" << edgeUniqueId(z);
  for (Integer z = 0, zs = nbFace(); z < zs; ++z)
    o << " F" << z << "=" << faceUniqueId(z);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer FullCellInfo::
memoryUsed(ItemTypeInfo* it, Integer parent_info, bool has_edge, bool has_amr, bool with_flags)
{
  Integer memory_used = 0;
  // basic description of a cell
  memory_used += 3 + 2 * it->nbLocalNode() + 2 * it->nbLocalFace();
  if (has_edge)
    memory_used += 2 * it->nbLocalEdge();
  // Factor *2: uid + type (all except node)
  if (parent_info & PI_Node)
    memory_used += it->nbLocalNode();
  if (parent_info & PI_Edge)
    memory_used += 2 * it->nbLocalEdge();
  if (parent_info & PI_Face)
    memory_used += 2 * it->nbLocalFace();
  if (parent_info & PI_Cell)
    memory_used += 2;
  if (has_amr)
    memory_used += 3;
  if (with_flags)
    memory_used += 1;
 
  return memory_used;
}
 
namespace
{
  class SerializerDumpAdapter
  {
   public:
 
    SerializerDumpAdapter(ISerializer* s)
    : m_serializer(s)
    {}
    void put(Int64 v)
    {
      m_serializer->putInt64(v);
    }
 
   private:
 
    ISerializer* m_serializer;
  };
 
  class ArrayDumpAdapter
  {
   public:
 
    ArrayDumpAdapter(Array<Int64>& a)
    : m_array_ref(a)
    {}
    void put(Int64 v)
    {
      m_array_ref.add(v);
    }
 
   private:
 
    Array<Int64>& m_array_ref;
  };
 
  template <typename Adapter> void
  _dumpCellInfo(Cell cell, Adapter buf, Integer parent_info,
                bool has_edge, bool has_amr, bool with_flags)
  {
    buf.put(cell.type());
    buf.put(cell.uniqueId().asInt64());
    buf.put(cell.owner());
    // Adds the list of nodes
    for (Item node : cell.nodes()) {
      buf.put(node.uniqueId().asInt64());
      buf.put(node.owner());
    }
    // Adds the list of edges
    if (has_edge)
      for (Edge edge : cell.edges()) {
        buf.put(edge.uniqueId().asInt64());
        buf.put(edge.owner());
      }
    // Adds the list of faces
    for (Face face : cell.faces()) {
      buf.put(face.uniqueId().asInt64());
      buf.put(face.owner());
    }
    if (parent_info & FullCellInfo::PI_Node) {
      for (Node node : cell.nodes()) {
        Item parent = node.parent(0);
        buf.put(parent.uniqueId().asInt64());
      }
    }
    if (parent_info & FullCellInfo::PI_Edge) {
      for (Edge edge : cell.edges()) {
        Item parent = edge.parent(0);
        buf.put(parent.uniqueId().asInt64());
        buf.put(parent.type());
      }
    }
    if (parent_info & FullCellInfo::PI_Face) {
      for (Face face : cell.faces()) {
        Item parent = face.parent(0);
        buf.put(parent.uniqueId().asInt64());
        buf.put(parent.type());
      }
    }
    if (parent_info & FullCellInfo::PI_Cell) {
      Item parent = cell.parent(0);
      buf.put(parent.uniqueId().asInt64());
      buf.put(parent.type());
    }
    if (has_amr) {
      buf.put(cell.level());
      if (cell.level() == 0) {
        buf.put(NULL_ITEM_ID);
        buf.put(NULL_ITEM_ID);
      }
      else {
        Cell hParent = cell.hParent();
        buf.put(hParent.uniqueId().asInt64());
        buf.put(hParent.whichChildAmI(cell));
      }
    }
    if (with_flags)
      buf.put(cell.itemBase().flags());
  }
 
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FullCellInfo::
dump(ItemInternal* icell, ISerializer* buf, Integer parent_info,
     bool has_edge, bool has_amr, bool with_flags)
{
  SerializerDumpAdapter adapter(buf);
  _dumpCellInfo(icell, adapter, parent_info, has_edge, has_amr, with_flags);
}
 
void FullCellInfo::
dump(Cell cell, Array<Int64>& buf, Integer parent_info,
     bool has_edge, bool has_amr, bool with_flags)
{
  ArrayDumpAdapter adapter(buf);
  _dumpCellInfo(cell, adapter, parent_info, has_edge, has_amr, with_flags);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer FullCellInfo::
parentInfo(IMesh* mesh)
{
  Integer info = 0;
  if (mesh->cellFamily()->parentFamily())
    info |= PI_Cell;
  if (mesh->faceFamily()->parentFamily())
    info |= PI_Face;
  if (mesh->edgeFamily()->parentFamily())
    info |= PI_Edge;
  if (mesh->nodeFamily()->parentFamily())
    info |= PI_Node;
  return info;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FullCellInfo::
_setInternalInfos()
{
  m_nb_node = m_type->nbLocalNode();
  if (m_has_edge)
    m_nb_edge = m_type->nbLocalEdge();
  else
    m_nb_edge = 0;
  m_nb_face = m_type->nbLocalFace();
  m_first_edge = 3 + m_nb_node * 2;
  m_first_face = m_first_edge + m_nb_edge * 2;
  m_first_parent_node = m_first_face + m_nb_face * 2;
  m_first_parent_edge = m_first_parent_node;
  if (m_parent_info & PI_Node)
    m_first_parent_edge += m_nb_node;
  m_first_parent_face = m_first_parent_edge;
  if (m_parent_info & PI_Edge)
    m_first_parent_face += m_nb_edge * 2;
  m_first_parent_cell = m_first_parent_face;
  if (m_parent_info & PI_Face)
    m_first_parent_cell += m_nb_face * 2;
  m_memory_used = m_first_parent_cell;
  if (m_parent_info & PI_Cell)
    m_memory_used += 2;
  if (m_has_amr) {
    m_first_hParent_cell = m_memory_used;
    m_memory_used += 3;
  }
  if (m_with_flags)
    m_memory_used += 1;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/