DynamicMeshChecker.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* DynamicMeshChecker.cc                                       (C) 2000-2025 */
/*                                                                           */
/* Class providing methods for mesh checking.                                */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/ValueChecker.h"
 
#include "arcane/mesh/DynamicMesh.h"
#include "arcane/mesh/ItemGroupsSynchronize.h"
#include "arcane/mesh/FaceReorienter.h"
#include "arcane/mesh/DynamicMeshChecker.h"
 
#include "arcane/core/MeshUtils.h"
#include "arcane/core/Properties.h"
#include "arcane/core/ItemPrinter.h"
#include "arcane/core/TemporaryVariableBuildInfo.h"
#include "arcane/core/IXmlDocumentHolder.h"
#include "arcane/core/XmlNodeList.h"
#include "arcane/core/IIOMng.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IParallelReplication.h"
#include "arcane/core/VariableCollection.h"
#include "arcane/core/NodesOfItemReorderer.h"
 
#include <set>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
DynamicMeshChecker::
DynamicMeshChecker(IMesh* mesh)
: TraceAccessor(mesh->traceMng())
, m_mesh(mesh)
{
  if (arcaneIsCheck())
    m_check_level = 1;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
DynamicMeshChecker::
~DynamicMeshChecker()
{
  delete m_var_cells_faces;
  delete m_var_cells_nodes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void DynamicMeshChecker::
checkValidMesh()
{
  info(4) << "Check mesh coherence.";
  checkValidConnectivity();
 
  for (IItemFamilyCollection::Enumerator i(m_mesh->itemFamilies()); ++i;) {
    IItemFamily* family = *i;
    //GG: check why this test exists.
    if (family->itemKind() >= NB_ITEM_KIND)
      continue;
    family->checkValid();
  }
  mesh_utils::checkMeshProperties(m_mesh, false, false, true);
 
  // Store in a cell variable the list of faces and
  // nodes that compose it.
  // This is only useful for checks
  // NOTE: currently set to false because it crashes if
  // initial partitioning is used in Arcane
  const bool global_check = false;
  if (m_check_level >= 1 && global_check) {
    if (!m_var_cells_faces)
      m_var_cells_faces = new VariableCellArrayInt64(VariableBuildInfo(m_mesh, "MeshTestCellFaces"));
 
    if (!m_var_cells_nodes)
      m_var_cells_nodes = new VariableCellArrayInt64(VariableBuildInfo(m_mesh, "MeshTestCellNodes"));
 
    CellGroup all_cells(m_mesh->allCells());
    Integer max_nb_face = 0;
    Integer max_nb_node = 0;
    ENUMERATE_CELL (i, all_cells) {
      Cell cell = *i;
      Integer nb_face = cell.nbFace();
      Integer nb_node = cell.nbNode();
      if (nb_face > max_nb_face)
        max_nb_face = nb_face;
      if (nb_node > max_nb_node)
        max_nb_node = nb_node;
    }
    m_var_cells_faces->resize(max_nb_face);
    m_var_cells_nodes->resize(max_nb_node);
    ENUMERATE_CELL (i, all_cells) {
      Cell cell = *i;
      Integer nb_face = cell.nbFace();
      for (Integer z = 0; z < nb_face; ++z)
        (*m_var_cells_faces)[cell][z] = cell.face(z).uniqueId().asInt64();
      Integer nb_node = cell.nbNode();
      for (Integer z = 0; z < nb_node; ++z)
        (*m_var_cells_nodes)[cell][z] = cell.node(z).uniqueId().asInt64();
    }
  }
  checkValidMeshFull();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
checkValidMeshFull()
{
  String func_name("DynamicMesh::checkValidMeshFull");
  info() << func_name << " on " << m_mesh->name();
  Integer nb_error = 0;
  VariableFaceInt64 var_faces(VariableBuildInfo(m_mesh, "MeshCheckFaces"));
  debug() << " VAR_FACE GROUP=" << var_faces.variable()->itemFamily()
          << " NAME=" << var_faces.itemGroup().name()
          << " FAMILY_NAME=" << var_faces.variable()->itemFamilyName()
          << " GROUP_NAME=" << var_faces.variable()->itemGroupName();
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Cell c = face.backCell();
    Int64 uid = c.null() ? NULL_ITEM_UNIQUE_ID : c.uniqueId();
    var_faces[face] = uid;
  }
  var_faces.synchronize();
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Cell c = face.backCell();
    Int64 uid = c.null() ? NULL_ITEM_UNIQUE_ID : c.uniqueId();
    if (uid != var_faces[face] && uid != NULL_ITEM_ID && var_faces[face] != NULL_ITEM_ID) {
      error() << func_name << " bad back cell in face uid=" << face.uniqueId();
      ++nb_error;
    }
  }
 
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Cell c = face.frontCell();
    Int64 uid = c.null() ? NULL_ITEM_UNIQUE_ID : c.uniqueId();
    var_faces[face] = uid;
  }
  var_faces.synchronize();
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Cell c = face.frontCell();
    Int64 uid = c.null() ? NULL_ITEM_UNIQUE_ID : c.uniqueId();
    if (uid != var_faces[face] && uid != NULL_ITEM_ID && var_faces[face] != NULL_ITEM_ID) {
      error() << func_name << " bad front cell in face uid=" << face.uniqueId();
      ++nb_error;
    }
  }
 
  ENUMERATE_CELL (icell, m_mesh->allCells()) {
    Cell cell = *icell;
    Integer cell_type = cell.type();
    if (cell_type == IT_Line2) {
      error() << func_name << " bad cell type in face uid=" << cell.uniqueId();
      ++nb_error;
    }
  }
 
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Integer face_type = face.type();
    if (face_type == IT_Vertex) {
      error() << func_name << " bad face type in face uid=" << face.uniqueId();
      ++nb_error;
    }
  }
 
  if (nb_error != 0)
    ARCANE_FATAL("Invalid mesh");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * \brief Checks that connectivity is valid.
 *
 * The checks cover the following points:
 * - no mesh entities having a null index.
 * - for faces, checks that at least one frontCell or backCell exists.
 *   Furthermore, if it has two cells, the backCell must always be the first.
 * - nodes and faces must have the same owner as one of the adjacent cells.
 * - checks that faces are correctly ordered and oriented
 */
void DynamicMeshChecker::
checkValidConnectivity()
{
  String func_name = "MeshChecker::checkValidConnectivity";
  debug() << func_name << " check";
 
  // Calls the checkValidConnectivity method for each family.
  IItemFamilyCollection item_families = m_mesh->itemFamilies();
  for (auto x = item_families.enumerator(); ++x;) {
    IItemFamily* f = *x;
    f->checkValidConnectivity();
  }
 
  if (!m_mesh->parentMesh()) {
    Integer index = 0;
    ENUMERATE_ (Face, i, m_mesh->allFaces()) {
      Face elem = *i;
      Cell front_cell = elem.frontCell();
      Cell back_cell = elem.backCell();
      if (front_cell.null() && back_cell.null())
        ARCANE_FATAL("Local face '{0}' has two null cell face=", index, ItemPrinter(elem));
      index++;
    }
  }
 
  // Checks that the cell<->node connectivity
  // is reciprocal
  ENUMERATE_NODE (inode, m_mesh->allNodes()) {
    Node node = *inode;
    for (Cell cell : node.cells()) {
      bool has_found = false;
      for (Node node2 : cell.nodes()) {
        if (node2 == node) {
          has_found = true;
          break;
        }
      }
      if (!has_found) {
        ARCANE_FATAL("Node uid={0} is connected to the cell uid={1} but the cell"
                     " is not connected to this node.",
                     ItemPrinter(node), ItemPrinter(cell));
      }
    }
  }
 
  // ATT: the following checks are not compatible with AMR
  // TODO : extend checks for AMR
  if (!m_mesh->isAmrActivated()) {
    // Checks that the cell<->edge connectivity
    // is reciprocal
    ENUMERATE_EDGE (iedge, m_mesh->allEdges()) {
      Edge edge = *iedge;
      for (Cell cell : edge.cells()) {
        bool has_found = false;
        for (Edge edge2 : cell.edges()) {
          if (edge2 == edge) {
            has_found = true;
            break;
          }
        }
        if (!has_found) {
          ARCANE_FATAL("Edge uid={0} is connected to the cell uid={1} but the cell"
                       " is not connected to this edge.",
                       ItemPrinter(edge), ItemPrinter(cell));
        }
      }
    }
  }
  // Checks that the cell<->face connectivity
  // is reciprocal
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    if (!m_mesh->isAmrActivated()) {
      for (Cell cell : face.cells()) {
        bool has_found = false;
        for (Face face2 : cell.faces()) {
          if (face2 == face) {
            has_found = true;
            break;
          }
        }
        if (!has_found) {
          ARCANE_FATAL("Face uid={0} is connected to the cell uid={1} but the cell"
                       " is not connected to this face.",
                       ItemPrinter(face), ItemPrinter(cell));
        }
      }
    }
    for (Cell cell : face.cells()) {
      bool has_found = false;
      for (Face face2 : cell.faces()) {
        if (face2 == face) {
          has_found = true;
          break;
        }
      }
      if (!has_found && (face.backCell().level() == face.frontCell().level())) {
        warning() << func_name << ". The face " << FullItemPrinter(face)
                  << " is connected to the cell " << FullItemPrinter(cell)
                  << " but the cell (level " << cell.level() << ")"
                  << " is not connected to the face.";
      }
    }
 
    Integer nb_cell = face.nbCell();
    Cell back_cell = face.backCell();
    Cell front_cell = face.frontCell();
    if ((back_cell.null() || front_cell.null()) && nb_cell == 2)
      ARCANE_FATAL("Face uid='{0}' bad number of cells face", ItemPrinter(face));
    // If we have two connected cells, then the back cell must be the first
    if (nb_cell == 2 && back_cell != face.cell(0))
      ARCANE_FATAL("Bad face face.backCell()!=face.cell(0) face={0} back_cell={1} from_cell={2} cell0={3}",
                   ItemPrinter(face), ItemPrinter(back_cell), ItemPrinter(front_cell), ItemPrinter(face.cell(0)));
  }
 
  _checkFacesOrientation();
  _checkEdgesOrientation();
 
  if (m_mesh->parentMesh()) {
    Integer nerror = 0;
    eItemKind kinds[] = { IK_Node, IK_Edge, IK_Face, IK_Cell };
    Integer nb_kind = sizeof(kinds) / sizeof(eItemKind);
 
    for (Integer i_kind = 0; i_kind < nb_kind; ++i_kind) {
      const eItemKind kind = kinds[i_kind];
      IItemFamily* family = m_mesh->itemFamily(kind);
      if (!family->parentFamily()) {
        error() << "Mesh " << m_mesh->name() << " : Family " << kind << " does not exist in mesh";
        ++nerror;
      }
      else {
        ENUMERATE_ITEM (iitem, family->allItems()) {
          const Item& item = *iitem;
          const Item& parent_item = item.parent();
          if (parent_item.itemBase().isSuppressed()) {
            error() << "Mesh " << m_mesh->name() << " : Inconsistent suppresssed parent item uid : "
                    << ItemPrinter(item) << " / " << ItemPrinter(parent_item);
            ++nerror;
          }
          if (parent_item.uniqueId() != item.uniqueId()) {
            error() << "Mesh " << m_mesh->name() << " : Inconsistent item/parent item uid : " << ItemPrinter(item);
            ++nerror;
          }
        }
      }
    }
    if (nerror > 0)
      ARCANE_FATAL("Mesh name={0} has {1} (see above)", m_mesh->name(), String::plural(nerror, "error"));
 
    // Checks the parallel consistency of the parent group
    nerror = 0;
    {
      ItemGroup parent_group = m_mesh->parentGroup();
      String var_name = String::format("SubMesh_{0}_GroupConsistencyChecker", parent_group.name());
      TemporaryVariableBuildInfo tvbi(m_mesh->parentMesh(), var_name, parent_group.itemFamily()->name());
      ItemVariableScalarRefT<Integer> var(tvbi, m_mesh->parentGroup().itemKind());
      var.fill(-1);
      ENUMERATE_ITEM (iitem, m_mesh->parentGroup()) {
        var[iitem] = iitem->owner();
      }
      nerror += var.checkIfSync(10);
    }
    if (nerror > 0)
      ARCANE_FATAL("Mesh name={0} has parent group consistency {1}\n"
                   "This usually means that parent group was not symmetrically built",
                   m_mesh->name(), String::plural(nerror, "error", false));
  }
 
  if (m_is_check_items_owner) {
    _checkValidItemOwner(m_mesh->nodeFamily());
    _checkValidItemOwner(m_mesh->edgeFamily());
    _checkValidItemOwner(m_mesh->faceFamily());
    _checkValidItemOwner(m_mesh->cellFamily());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
updateAMRFaceOrientation()
{
  String func_name = "MeshChecker::updateAMRFaceOrientation";
  FaceReorienter fr(m_mesh);
  ENUMERATE_FACE (iface, m_mesh->allFaces()) {
    Face face = *iface;
    Integer nb_cell = face.nbCell();
    Cell back_cell = face.backCell();
    Cell front_cell = face.frontCell();
    if ((back_cell.null() || front_cell.null()) && nb_cell == 2)
      ARCANE_FATAL("Bad number of cells for face={0}", ItemPrinter(face));
    // If we have two connected cells, then the back cell must be the first
    if (nb_cell == 2 && back_cell != face.cell(0))
      ARCANE_FATAL("Bad face face.backCell()!=face.cell(0) face={0} back_cell={1} from_cell={2} cell0={3}",
                   ItemPrinter(face), ItemPrinter(back_cell), ItemPrinter(front_cell), ItemPrinter(face.cell(0)));
 
    // This could undoubtedly be optimized
    fr.checkAndChangeOrientationAMR(face);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
updateAMRFaceOrientation(ArrayView<Int64> ghost_cell_to_refine)
{
  ItemInternalList cells = m_mesh->itemsInternal(IK_Cell);
  UniqueArray<Integer> lids(ghost_cell_to_refine.size());
  m_mesh->cellFamily()->itemsUniqueIdToLocalId(lids, ghost_cell_to_refine, true);
  FaceReorienter fr(m_mesh);
  std::set<Int64> set;
  typedef std::pair<std::set<Int64>::iterator, bool> return_type;
  for (Integer i = 0, n = lids.size(); i < n; ++i) {
    Cell icell = cells[lids[i]];
    for (Integer ic = 0, nchild = icell.nbHChildren(); ic < nchild; ++ic) {
      Cell child = icell.hChild(ic);
      for (Face face : child.faces()) {
        return_type value = set.insert(face.uniqueId());
        if (value.second) {
          fr.checkAndChangeOrientationAMR(face);
        }
      }
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void DynamicMeshChecker::
_checkFacesOrientation()
{
  bool is_1d = (m_mesh->dimension() == 1);
  //Temporary: for now, does not test orientation in 1D.
  if (is_1d)
    return;
 
  String func_name = "MeshChecker::_checkFacesOrientation";
 
  Int64UniqueArray work_face_sorted_nodes;
  IntegerUniqueArray work_face_nodes_index;
  Int64UniqueArray work_face_orig_nodes_uid;
  ItemTypeMng* item_type_mng = m_mesh->itemTypeMng();
  NodesOfItemReorderer face_reorderer(item_type_mng);
  ENUMERATE_ (Cell, icell, m_mesh->allCells()) {
    Cell cell = *icell;
    const ItemTypeInfo* type = cell.typeInfo();
    Int32 cell_nb_face = type->nbLocalFace();
    for (Integer i_face = 0; i_face < cell_nb_face; ++i_face) {
      const ItemTypeInfo::LocalFace& lf = type->localFace(i_face);
      Integer face_nb_node = lf.nbNode();
 
      work_face_orig_nodes_uid.resize(face_nb_node);
      for (Integer z = 0; z < face_nb_node; ++z)
        work_face_orig_nodes_uid[z] = cell.node(lf.node(z)).uniqueId();
 
      bool is_reorder = false;
      if (is_1d) {
        is_reorder = face_reorderer.reorder1D(i_face, work_face_orig_nodes_uid[0]);
      }
      else
        is_reorder = face_reorderer.reorder(ItemTypeId::fromInteger(lf.typeId()), work_face_orig_nodes_uid);
      ConstArrayView<Int64> face_sorted_nodes(face_reorderer.sortedNodes());
 
      Face cell_face = cell.face(i_face);
      if (cell_face.nbNode() != face_nb_node)
        ARCANE_FATAL("Incoherent number of node for 'face' and 'localFace'"
                     " cell={0} face={1} nb_local_node={2} nb_face_node={3}",
                     ItemPrinter(cell), ItemPrinter(cell_face), face_nb_node, cell_face.nbNode());
 
      for (Integer z = 0; z < face_nb_node; ++z) {
        if (cell_face.node(z).uniqueId() != face_sorted_nodes[z])
          ARCANE_FATAL("Bad node unique id for face: cell={0} face={1} cell_node_uid={2} face_node_uid={3} z={4}",
                       ItemPrinter(cell), ItemPrinter(cell_face), face_sorted_nodes[z],
                       cell_face.node(z).uniqueId());
      }
      if (is_reorder) {
        Cell front_cell = cell_face.frontCell();
        if (front_cell != cell) {
          if (!front_cell.null())
            ARCANE_FATAL("Bad orientation for face. Should be front cell: cell={0} face={1} front_cell={2}",
                         ItemPrinter(cell), ItemPrinter(cell_face), ItemPrinter(front_cell));
          else
            ARCANE_FATAL("Bad orientation for face. Should be front cell (no front cell) cell={0} face={1}",
                         ItemPrinter(cell), ItemPrinter(cell_face));
        }
      }
      else {
        Cell back_cell = cell_face.backCell();
        if (back_cell != cell) {
          if (!back_cell.null())
            ARCANE_FATAL("Bad orientation for face. Should be back cell: cell={0} face={1} front_cell={2}",
                         ItemPrinter(cell), ItemPrinter(cell_face), ItemPrinter(back_cell));
          else
            ARCANE_FATAL("Bad orientation for face. Should be back cell (no back cell) cell={0} face={1}",
                         ItemPrinter(cell), ItemPrinter(cell_face));
        }
      }
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void DynamicMeshChecker::
_checkEdgesOrientation()
{
  // For edges, checks that the uniqueId() of the first node is
  // less than that of the second.
  Int32 nb_error = 0;
  ENUMERATE_ (Edge, iedge, m_mesh->allEdges()) {
    Edge edge = *iedge;
    Int32 nb_node = edge.nbNode();
    if (nb_node >= 2) {
      Node node0 = edge.node(0);
      Node node1 = edge.node(1);
      if (node0.uniqueId() > node1.uniqueId()) {
        ++nb_error;
        info() << "Error: bad orientation for edge '" << ItemPrinter(edge)
               << " n0=" << node0.uniqueId() << " n1=" << node1.uniqueId();
      }
    }
  }
  if (nb_error != 0)
    ARCANE_FATAL("Bad connectivity for '{0}' edges", nb_error);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
_checkValidItemOwner(IItemFamily* family)
{
  // For non-sub-meshes, every sub-item
  // (Node, Edge or Face) must have an adjacent cell with the same owner,
  // unless orphan entities are allowed and the entity is not
  // connected to any cell.
  // For sub-meshes, furthermore, every item must have the same owner
  // as its parent.
  bool allow_orphan_items = m_mesh->meshKind().isNonManifold();
 
  Integer nerror = 0;
  if (!m_mesh->parentMesh()) {
 
    if (family->itemKind() == IK_Cell)
      return; // implicitly valid for cells
 
    ItemGroup own_items = family->allItems().own();
    ENUMERATE_ITEM (iitem, own_items) {
      Item item = *iitem;
      Int32 owner = item.owner();
      bool is_ok = false;
      ItemVectorView cells = item.itemBase().cellList();
      if (cells.size() == 0 && allow_orphan_items)
        continue;
      for (Item cell : cells) {
        if (cell.owner() == owner) {
          is_ok = true;
          break;
        }
      }
      if (!is_ok) {
        OStringStream ostr;
        Integer index = 0;
        ostr() << " nb_cell=" << cells.size();
        for (Item cell : cells) {
          ostr() << " SubCell i=" << index << " cell=" << ItemPrinter(cell);
          ++index;
        }
        error() << "Mesh " << m_mesh->name() << " family=" << family->name()
                << " Item" << ItemPrinter(item) << " has no cell with same owner:"
                << ostr.str();
        ++nerror;
      }
    }
  }
  else {
    ENUMERATE_ITEM (iitem, family->allItems()) {
      Item item = *iitem;
      Item parent_item = item.parent();
      if (parent_item.owner() != item.owner()) {
        error() << "Mesh " << m_mesh->name() << " : Inconsistent item/parent item owner : "
                << ItemPrinter(item) << " / " << ItemPrinter(parent_item);
        ++nerror;
      }
    }
  }
 
  if (nerror > 0)
    ARCANE_FATAL("mesh {0} family={1} has {2}", m_mesh->name(), family->name(),
                 String::plural(nerror, "owner error"));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
checkVariablesSynchronization()
{
  Int64 nb_diff = 0;
  VariableCollection used_vars(m_mesh->variableMng()->usedVariables());
  for (VariableCollection::Enumerator i_var(used_vars); ++i_var;) {
    IVariable* var = *i_var;
    switch (var->itemKind()) {
    case IK_Node:
    case IK_Edge:
    case IK_Face:
    case IK_Cell:
    case IK_DoF:
      nb_diff += var->checkIfSync(10);
      break;
    case IK_Particle:
    case IK_Unknown:
      break;
    }
  }
  if (nb_diff != 0)
    ARCANE_FATAL("Error in checkVariablesSynchronization() nb_diff=", nb_diff);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
checkItemGroupsSynchronization()
{
  Int64 nb_diff = 0;
  // TODO: iterate over all families (except particles)
  ItemGroupsSynchronize node_sync(m_mesh->nodeFamily());
  nb_diff += node_sync.checkSynchronize();
  ItemGroupsSynchronize edge_sync(m_mesh->edgeFamily());
  nb_diff += edge_sync.checkSynchronize();
  ItemGroupsSynchronize face_sync(m_mesh->faceFamily());
  nb_diff += face_sync.checkSynchronize();
  ItemGroupsSynchronize cell_sync(m_mesh->cellFamily());
  nb_diff += cell_sync.checkSynchronize();
  if (nb_diff != 0)
    ARCANE_FATAL("some groups are not synchronized nb_diff={0}", nb_diff);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void DynamicMeshChecker::
checkGhostCells()
{
  pwarning() << "CHECK GHOST CELLS";
  Integer sid = m_mesh->meshPartInfo().partRank();
  ENUMERATE_CELL (icell, m_mesh->cellFamily()->allItems()) {
    Cell cell = *icell;
    if (cell.isOwn())
      continue;
    bool is_ok = false;
    for (Node node : cell.nodes()) {
      for (Cell cell2 : node.cells()) {
        if (cell2.owner() == sid) {
          is_ok = true;
        }
      }
    }
    if (!is_ok)
      info() << "WARNING: Cell " << ItemPrinter(cell) << " should not be a ghost cell";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
checkMeshFromReferenceFile()
{
  if (!m_compare_reference_file)
    return;
 
  IParallelMng* pm = m_mesh->parallelMng();
 
  if (!pm->isParallel())
    return; // only in parallel
 
  debug() << "Testing the mesh against the initial mesh";
  String base_file_name("meshconnectivity");
  // In parallel, compare the current mesh with the file
  // containing the full connectivity (sequential case)
  IIOMng* io_mng = pm->ioMng();
  ScopedPtrT<IXmlDocumentHolder> xml_doc(io_mng->parseXmlFile(base_file_name));
  if (xml_doc.get()) {
    XmlNode doc_node = xml_doc->documentNode();
    if (!doc_node.null())
      mesh_utils::checkMeshConnectivity(m_mesh, doc_node, true);
  }
  else {
    warning() << "Can't test the subdomain coherence "
              << "against the initial mesh";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
checkValidReplication()
{
  info() << "Checking valid replication";
  IParallelMng* mesh_pm = m_mesh->parallelMng();
  IParallelReplication* pr = mesh_pm->replication();
  if (!pr->hasReplication())
    return;
 
  IParallelMng* pm = pr->replicaParallelMng();
 
  // Checks that all families (except particles) are the same
  UniqueArray<IItemFamily*> wanted_same_family;
 
  for (IItemFamilyCollection::Enumerator i(m_mesh->itemFamilies()); ++i;) {
    IItemFamily* family = *i;
    if (family->itemKind() != IK_Particle)
      wanted_same_family.add(family);
  }
  ValueChecker vc(A_FUNCINFO);
 
  // Checks that everyone has the same number of families.
  Integer nb_family = wanted_same_family.size();
  Integer max_nb_family = pm->reduce(Parallel::ReduceMax, nb_family);
  vc.areEqual(nb_family, max_nb_family, "Bad number of family");
 
  // Checks that all families have the same number of elements.
  //TODO: it should also check that the family names match.
  {
    UniqueArray<Int32> families_size(nb_family);
    for (Integer i = 0; i < nb_family; ++i)
      families_size[i] = wanted_same_family[i]->nbItem();
    UniqueArray<Int32> global_families_size(families_size);
    pm->reduce(Parallel::ReduceMax, global_families_size.view());
    vc.areEqualArray(global_families_size, families_size, "Bad family");
  }
 
  // Checks that all families have the same entities (same uniqueId())
  {
    UniqueArray<Int64> unique_ids;
    UniqueArray<Int64> global_unique_ids;
    for (Integer i = 0; i < nb_family; ++i) {
      ItemGroup group = wanted_same_family[i]->allItems();
      unique_ids.resize(group.size());
      Integer index = 0;
      ENUMERATE_ITEM (iitem, group) {
        unique_ids[index] = iitem->uniqueId();
        ++index;
      }
      global_unique_ids.resize(group.size());
      global_unique_ids.copy(unique_ids);
      pm->reduce(Parallel::ReduceMax, global_unique_ids.view());
      String message = String::format("Bad unique ids for family '{0}'",
                                      wanted_same_family[i]->name());
      vc.areEqualArray(global_unique_ids, unique_ids, message);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DynamicMeshChecker::
_checkReplicationFamily(IItemFamily*)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/