PolyhedralMesh.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* PolyhedralMesh.cc                                           (C) 2000-2026 */
/*                                                                           */
/* Implémentation du maillage polyédrique utilisant la structure de données  */
/* Neo.                                                                      */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include <memory>
 
#include "arcane/mesh/PolyhedralMesh.h"
 
#include "ItemFamilyNetwork.h"
#include "ItemFamilyPolicyMng.h"
#include "arcane/mesh/MeshExchangeMng.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/ItemSharedInfo.h"
#include "arcane/core/ItemTypeInfo.h"
#include "arcane/core/ItemTypeMng.h"
#include "arcane/core/VariableBuildInfo.h"
#include "arcane/core/MeshBuildInfo.h"
#include "arcane/core/ServiceFactory.h"
#include "arcane/core/AbstractService.h"
#include "arcane/core/CommonVariables.h"
#include "arcane/core/IMeshFactory.h"
#include "arcane/core/ItemInternal.h"
#include "arcane/core/IDoFFamily.h"
#include "arcane/core/IMeshCompactMng.h"
#include "arcane/core/IMeshCompacter.h"
#include "arcane/core/IMeshExchanger.h"
#include "arcane/core/IGhostLayerMng.h"
#include "arcane/core/MeshVisitor.h"
#include "arcane/core/internal/IItemFamilyInternal.h"
#include "arcane/core/internal/IItemFamilySerializerMngInternal.h"
#include "arcane/core/internal/IVariableMngInternal.h"
#include "arcane/core/internal/IPolyhedralMeshModifier.h"
#include "arcane/core/internal/IMeshModifierInternal.h"
#include "arcane/core/Connectivity.h"
 
#include "arcane/mesh/ItemFamily.h"
#include "arcane/mesh/DynamicMeshKindInfos.h"
#include "arcane/mesh/UnstructuredMeshUtilities.h"
#include "arcane/mesh/GhostLayerMng.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/FatalErrorException.h"
#include "arccore/base/StringBuilder.h"
 
#ifdef ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
#include "arcane/core/IMeshMng.h"
#include "arcane/core/MeshHandle.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/internal/IMeshInternal.h"
#include "arcane/core/IVariableSynchronizer.h"
#include "arcane/mesh/ItemFamilyPolicyMng.h"
#include "arcane/mesh/ItemFamilySerializer.h"
#include "arcane/utils/Collection.h"
#include "arcane/utils/List.h"
#include "arcane/utils/PlatformUtils.h"
 
#include "neo/Mesh.h"
#include "neo/Utils.h"
#include "ItemConnectivityMng.h"
 
#include "arcane/core/ItemPrinter.h"
 
#endif
 
// #define ARCANE_DEBUG_POLYHEDRAL_MESH
#define ARCANE_DEBUG_LOAD_BALANCING
 
#ifdef ARCANE_DEBUG_LOAD_BALANCING
static bool arcane_debug_load_balancing = true;
#else
static bool arcane_debug_load_balancing = false;
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_errorEmptyMesh() const
{
  ARCANE_FATAL("Impossible d'utiliser PolyhedralMesh si Arcane n'est pas lié à lib Neo");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
namespace PolyhedralTools
{
  class ItemLocalIds
  {
    Neo::FutureItemRange m_future_items;
    std::shared_ptr<Neo::EndOfMeshUpdate> m_mesh_state = nullptr;
 
   public:
 
    void fillArrayView(Int32ArrayView local_ids, Neo::EndOfMeshUpdate mesh_state)
    {
      auto lids = m_future_items.get(mesh_state);
      if (local_ids.size() != lids.size())
        ARCANE_FATAL("Impossible de remplir local_ids view, sa taille {0} != {1} (taille de l'élément ajouté)", local_ids.size(), m_future_items.size());
      std::copy(lids.begin(), lids.end(), local_ids.begin());
    }
 
    void fillArrayView(Int32ArrayView local_ids)
    {
      ARCANE_CHECK_POINTER2(m_mesh_state.get(), "PolyhedralTools::ItemLocalIds doit avoir un état de maillage de fin valide");
      fillArrayView(local_ids, *m_mesh_state);
    }
 
    Integer size() const noexcept { return m_future_items.size(); }
    bool isFilled() const noexcept { return m_mesh_state.get() != nullptr; };
    void checkIsFilled(String error_message) const noexcept
    {
      if (!isFilled())
        ARCANE_FATAL("Les IDs locaux des éléments ne sont pas remplis." + error_message);
    }
    friend class mesh::PolyhedralMeshImpl;
    friend class mesh::PolyhedralMesh;
  };
} // namespace PolyhedralTools
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class PolyhedralFamilySerializer;
class PolyhedralFamilySerializerMng : public IItemFamilySerializerMngInternal
{
  PolyhedralMesh* m_mesh = nullptr;
  Integer m_nb_serializers = 0;
  UniqueArray<PolyhedralFamilySerializer*> m_serializers;
 
 public:
 
  explicit PolyhedralFamilySerializerMng(PolyhedralMesh* mesh)
  : m_mesh(mesh)
  {
    ARCANE_CHECK_POINTER2(mesh, "Doit donner un pointeur PolyhedralMesh non nul.");
  }
 
  void addSerializer(PolyhedralFamilySerializer* serializer)
  {
    m_serializers.push_back(serializer);
    ++m_nb_serializers;
  }
 
  void finalizeItemAllocation() override;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class PolyhedralFamilySerializer : public IItemFamilySerializer
{
 private:
 
  PolyhedralMesh* m_mesh = nullptr;
  IItemFamily* m_family = nullptr;
  PolyhedralFamilySerializerMng* m_mng = nullptr;
  ItemData m_item_data;
  UniqueArray<Int32Array*> m_deserialized_lids_array;
  UniqueArray<std::shared_ptr<PolyhedralTools::ItemLocalIds>> m_future_item_lids_array;
  ItemAllocationInfo::FamilyInfo m_family_info;
 
 public:
 
  explicit PolyhedralFamilySerializer(PolyhedralMesh* mesh, IItemFamily* family, PolyhedralFamilySerializerMng* mng)
  : m_mesh(mesh)
  , m_family(family)
  , m_mng(mng)
  {}
 
  PolyhedralFamilySerializer(const PolyhedralFamilySerializer&) = delete;
  PolyhedralFamilySerializer& operator=(const PolyhedralFamilySerializer&) = delete;
 
  ArrayView<std::shared_ptr<PolyhedralTools::ItemLocalIds>> itemLidsArray() { return m_future_item_lids_array.view(); }
 
 public:
 
  void serializeItems(ISerializer* buf, Int32ConstArrayView items_local_ids) override;
  void deserializeItems(ISerializer* buf, Int32Array* items_local_ids) override;
 
  void clear()
  {
    m_item_data.clear();
    m_deserialized_lids_array.clear();
    m_future_item_lids_array.clear();
    m_family_info.clear();
  }
 
  void fillDeserializedLocalIds()
  {
    auto index = 0;
    for (auto item_lids_array : m_deserialized_lids_array) {
      auto& future_item_lids = m_future_item_lids_array[index];
      future_item_lids->checkIsFilled("Impossible de remplir les IDs locaux désérialisés, les IDs locaux des éléments futurs ne sont pas remplis.");
      item_lids_array->resize(future_item_lids->size());
      future_item_lids->fillArrayView(item_lids_array->view());
      ++index;
    }
    clear();
  }
 
  IItemFamilySerializerMngInternal* mng()
  {
    return m_mng;
  }
 
  // no need to distinguish between dependency or relation in Neo graph
  void serializeItemRelations(ISerializer*, Int32ConstArrayView) override {}
  void deserializeItemRelations(ISerializer*, Int32Array*) override {}
 
 private:
 
  void _fillItemData(Int32ConstArrayView items_local_ids);
  void _fillItemFamilyInfo(const ItemData& item_data,
                           StringConstArrayView connected_family_names,
                           StringConstArrayView connectivity_names)
  {
    // clear data
    m_family_info.clear();
    // Check info in ItemData
    if (m_family != item_data.itemFamily())
      ARCANE_FATAL("PolyhedralFamilySerializer: Incompatibilité de famille. La famille synchronisée est {0} et la famille sérialisée est {1}",
                   m_family->name(), item_data.itemFamily()->name());
    m_family_info.name = item_data.itemFamily()->name();
    m_family_info.item_kind = item_data.itemFamily()->itemKind();
    auto& connected_family_infos = m_family_info.connected_family_infos;
    auto nb_connected_family = item_data.itemInfos()[0];
    connected_family_infos.resize(nb_connected_family);
    auto& item_uids = m_family_info._item_uids_data;
    item_uids.reserve(item_data.nbItems());
    auto item_infos = item_data.itemInfos();
    for (auto connected_family_info : connected_family_infos) {
      connected_family_info._connected_items_uids_data.reserve(4 * item_uids.size());
      connected_family_info._nb_connected_items_per_item_data.reserve(item_uids.size());
    }
    for (auto index = 1; index < item_infos.size();) {
      item_uids.push_back(item_infos[index + 1]); // first index is item type, not used in polyhedral
      index += 2;
      for (auto connected_family_index = 0; connected_family_index < nb_connected_family; ++connected_family_index) {
        eItemKind family_kind = static_cast<eItemKind>(item_infos[index]);
        auto* connected_family = m_mesh->findItemFamily(family_kind, connected_family_names[connected_family_index], false, false);
        ARCANE_CHECK_POINTER(connected_family);
        auto& current_connected_family_infos = connected_family_infos[connected_family_index];
        current_connected_family_infos.item_kind = family_kind;
        current_connected_family_infos.name = connected_family->name();
        current_connected_family_infos.connectivity_name = connectivity_names[connected_family_index];
        ++index;
        auto nb_connected_items = static_cast<Int32>(item_infos[index]);
        ++index;
        current_connected_family_infos._nb_connected_items_per_item_data.push_back(nb_connected_items);
        auto real_nb_connected_items = nb_connected_items;
        if (m_family->itemKind() == IK_Face && connected_family->itemKind() == IK_Cell)
          real_nb_connected_items = 2; // 2 mailles sont stockées, même si l'une est nulle (limite)
        current_connected_family_infos._connected_items_uids_data.addRange(item_infos.subView(index, real_nb_connected_items));
        index += real_nb_connected_items;
      }
    }
    // Update FamilyInfo views
    m_family_info.updateViewsFromInternalData();
    // get owners
    m_family_info.item_owners = item_data.itemOwners();
  }
 
  IItemFamily* family() const override
  {
    return m_family;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void PolyhedralFamilySerializerMng::
finalizeItemAllocation()
{
  UniqueArray<std::shared_ptr<PolyhedralTools::ItemLocalIds>> future_item_lids;
  for (auto family_serializer : m_serializers) {
    for (auto& item_lids : family_serializer->itemLidsArray()) {
      future_item_lids.push_back(item_lids);
    }
  }
  m_mesh->applyScheduledAllocateItems(future_item_lids);
  for (auto family_serializer : m_serializers) {
    family_serializer->fillDeserializedLocalIds();
  }
  m_serializers.clear();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class PolyhedralFamilyPolicyMng
: public ItemFamilyPolicyMng
{
 public:
 
  PolyhedralFamilyPolicyMng(PolyhedralMesh* mesh, ItemFamily* family)
  : ItemFamilyPolicyMng(family)
  , m_mesh(mesh)
  , m_family(family)
  {}
 
 public:
 
  IItemFamilySerializer* createSerializer(bool) override
  {
    return new PolyhedralFamilySerializer(m_mesh, m_family, m_mesh->polyhedralFamilySerializerMng());
  }
 
 private:
 
  PolyhedralMesh* m_mesh = nullptr;
  ItemFamily* m_family = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class PolyhedralFamily
: public ItemFamily
, public IDoFFamily
{
  ItemSharedInfoWithType* m_shared_info = nullptr;
  Int32UniqueArray m_empty_connectivity{ 0 };
  Int32UniqueArray m_empty_connectivity_indexes;
  Int32UniqueArray m_empty_connectivity_nb_item;
  PolyhedralMesh* m_mesh = nullptr;
 
 public:
 
  inline static const String m_arcane_item_lids_property_name{ "Arcane_Item_Lids" }; // inline used to initialize within the declaration
  inline static const String m_arcane_remove_item_property_name{ "Arcane_Remove_Items" }; // inline used to initialize within the declaration
 
 public:
 
  PolyhedralFamily(PolyhedralMesh* mesh, eItemKind ik, String name)
  : ItemFamily(mesh, ik, name)
  , m_mesh(mesh)
  {}
 
 public:
 
  void preAllocate(Integer nb_item)
  {
    Integer nb_hash = itemsMap().nbBucket();
    Integer wanted_size = 2 * (nb_item + nbItem());
    if (nb_hash < wanted_size)
      itemsMap().resize(wanted_size, true);
    m_empty_connectivity_indexes.resize(nb_item + nbItem(), 0);
    m_empty_connectivity_nb_item.resize(nb_item + nbItem(), 0);
    _updateEmptyConnectivity();
  }
 
  ItemInternal* _allocItem(const Int64 uid, const Int32 owner)
  {
    bool need_alloc; // given by alloc
    ItemInternal* item_internal = ItemFamily::_findOrAllocOne(uid, need_alloc);
    if (!need_alloc)
      item_internal->setUniqueId(uid);
    else {
      _allocateInfos(item_internal, uid, m_shared_info);
    }
    item_internal->setOwner(owner, m_sub_domain_id);
    return item_internal;
  }
 
  void addItems(Int64ConstSmallSpan uids, Int32ArrayView items)
  {
    Int32UniqueArray owners(uids.size(), m_sub_domain_id);
    addItems(uids, items, owners);
  }
 
  void addItems(Int64ConstSmallSpan uids, Int32ArrayView items, Int32ConstArrayView owners)
  {
    if (uids.empty())
      return;
    ARCANE_ASSERT((uids.size() == items.size()), ("one must have items.size==uids.size()"));
    preAllocate(uids.size());
    auto index{ 0 };
    for (auto uid : uids) {
      ItemInternal* ii = _allocItem(uid, owners[index]);
      items[index] = ii->localId();
      ++index;
    }
    m_need_prepare_dump = true;
    _updateItemInternalList();
  }
 
  void removeItems(Int32ConstArrayView local_ids)
  {
    _removeMany(local_ids);
  }
 
  void _updateItemInternalList()
  {
    switch (itemKind()) {
    case IK_Cell:
      m_item_internal_list->cells = _itemsInternal();
      break;
    case IK_Face:
      m_item_internal_list->faces = _itemsInternal();
      break;
    case IK_Edge:
      m_item_internal_list->edges = _itemsInternal();
      break;
    case IK_Node:
      m_item_internal_list->nodes = _itemsInternal();
      break;
    case IK_DoF:
    case IK_Particle:
    case IK_Unknown:
      break;
    }
  }
 
  void _updateEmptyConnectivity()
  {
    auto item_internal_connectivity_list = itemInternalConnectivityList();
    for (auto item_kind = 0; item_kind < ItemInternalConnectivityList::MAX_ITEM_KIND; ++item_kind) {
      item_internal_connectivity_list->_setConnectivityList(item_kind, m_empty_connectivity);
      item_internal_connectivity_list->_setConnectivityIndex(item_kind, m_empty_connectivity_indexes);
      item_internal_connectivity_list->_setConnectivityNbItem(item_kind, m_empty_connectivity_nb_item);
    }
  }
 
  // IItemFamily
  IDoFFamily* toDoFFamily() override
  {
    return this;
  }
  // todo bloquer toutes les methodes d'allocation de IItemFamily
 
  void build() override
  {
    ItemFamily::build();
    m_sub_domain_id = subDomain()->subDomainId();
    ItemTypeMng* itm = m_mesh->itemTypeMng();
    ItemTypeInfo* dof_type_info = itm->typeFromId(IT_NullType);
    m_shared_info = _findSharedInfo(dof_type_info);
    _updateEmptyConnectivity();
    ItemFamily::setPolicyMng(new PolyhedralFamilyPolicyMng{ m_mesh, this });
  }
 
  void addGhostItems(Int64ConstArrayView unique_ids, Int32ArrayView items, Int32ConstArrayView owners) override
  {
    auto* polyhedral_mesh_modifier = m_mesh->_internalApi()->polyhedralMeshModifier();
    ARCANE_CHECK_POINTER(polyhedral_mesh_modifier);
    polyhedral_mesh_modifier->addItems(unique_ids, items, owners, ItemFamily::itemKind(), name());
  }
 
  // IDoFFamily
  String name() const override { return ItemFamily::name(); }
  String fullName() const override { return ItemFamily::fullName(); }
  Integer nbItem() const override { return ItemFamily::nbItem(); }
  ItemGroup allItems() const override { return ItemFamily::allItems(); }
  void endUpdate() override
  {
    return ItemFamily::endUpdate();
  }
  IItemFamily* itemFamily() override { return this; }
 
  DoFVectorView addDoFs(Int64ConstArrayView dof_uids, Int32ArrayView dof_lids) override
  {
    auto* polyhedral_mesh_modifier = m_mesh->_internalApi()->polyhedralMeshModifier();
    ARCANE_CHECK_POINTER(polyhedral_mesh_modifier);
    polyhedral_mesh_modifier->addItems(dof_uids, dof_lids, ItemFamily::itemKind(), name());
    return ItemFamily::view(dof_lids);
  }
 
  DoFVectorView addGhostDoFs(Int64ConstArrayView dof_uids, Int32ArrayView dof_lids,
                             Int32ConstArrayView owners) override
  {
    addGhostItems(dof_uids, dof_lids, owners);
    return ItemFamily::view(dof_lids);
  }
 
  void removeDoFs(Int32ConstArrayView items_local_id) override
  {
    auto* mesh_modifier = m_mesh->_internalApi()->polyhedralMeshModifier();
    mesh_modifier->removeItems(items_local_id, ItemFamily::itemKind(), m_name);
  }
};
 
} // namespace Arcane::mesh
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace mesh
{
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
 
  class PolyhedralMeshImpl
  {
    ISubDomain* m_subdomain;
    Neo::Mesh m_mesh{ "Test" };
 
    template <eItemKind IK>
    class ItemKindTraits
    {
      static const Neo::ItemKind item_kind = Neo::ItemKind::IK_None;
    };
 
   public:
 
    static Neo::ItemKind itemKindArcaneToNeo(eItemKind ik)
    {
      switch (ik) {
      case IK_Cell:
        return Neo::ItemKind::IK_Cell;
      case IK_Face:
        return Neo::ItemKind::IK_Face;
      case IK_Edge:
        return Neo::ItemKind::IK_Edge;
      case IK_Node:
        return Neo::ItemKind::IK_Node;
      case IK_DoF:
        return Neo::ItemKind::IK_Dof;
      case IK_Unknown:
      case IK_Particle:
        return Neo::ItemKind::IK_None;
      }
      return Neo::ItemKind::IK_Node;
    }
 
    static eItemKind itemKindNeoToArcane(Neo::ItemKind ik)
    {
      switch (ik) {
      case Neo::ItemKind::IK_Cell:
        return IK_Cell;
      case Neo::ItemKind::IK_Face:
        return IK_Face;
      case Neo::ItemKind::IK_Edge:
        return IK_Edge;
      case Neo::ItemKind::IK_Node:
        return IK_Node;
      case Neo::ItemKind::IK_Dof:
        return IK_DoF;
      case Neo::ItemKind::IK_None:
        return IK_Unknown;
      }
      return IK_Node;
    }
 
   public:
 
    explicit PolyhedralMeshImpl(ISubDomain* subDomain)
    : m_subdomain(subDomain)
    , m_mesh(String::format(subDomain->defaultMeshHandle().meshName(), "Polyhedral").localstr(), subDomain->parallelMng()->commRank())
    {}
 
   public:
 
    String name() const { return m_mesh.name(); }
 
    Integer dimension() const { return m_mesh.dimension(); }
 
    Integer nbNode() const { return m_mesh.nbNodes(); }
    Integer nbEdge() const { return m_mesh.nbEdges(); }
    Integer nbFace() const { return m_mesh.nbFaces(); }
    Integer nbCell() const { return m_mesh.nbCells(); }
    Integer nbItem(eItemKind ik) const { return m_mesh.nbItems(itemKindArcaneToNeo(ik)); }
 
    SmallSpan<const Neo::Mesh::Connectivity> connectivities(IItemFamily* source_family)
    {
      auto& neo_source_family = m_mesh.findFamily(itemKindArcaneToNeo(source_family->itemKind()), source_family->name().localstr());
      auto connectivities = m_mesh.getConnectivities(neo_source_family);
      return { connectivities.begin(), connectivities.size() };
    }
 
    static void _setFaceInfos(Int32 mod_flags, Face& face)
    {
      Int32 face_flags = face.itemBase().flags();
      face_flags &= ~ItemFlags::II_InterfaceFlags;
      face_flags |= mod_flags;
      face.mutableItemBase().setFlags(face_flags);
    }
 
    /*---------------------------------------------------------------------------*/
 
    void addFamily(eItemKind ik, const String& name)
    {
      m_mesh.addFamily(itemKindArcaneToNeo(ik), name.localstr());
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleAddItems(PolyhedralFamily* arcane_item_family,
                          Int64ConstSmallSpan uids,
                          PolyhedralTools::ItemLocalIds& item_local_ids)
    {
      scheduleAddItems(arcane_item_family, uids, Int32ConstSmallSpan{}, item_local_ids);
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleAddItems(PolyhedralFamily* arcane_item_family,
                          Int64ConstSmallSpan uids,
                          Int32ConstSmallSpan owners,
                          PolyhedralTools::ItemLocalIds& item_local_ids)
    {
      auto& added_items = item_local_ids.m_future_items;
      auto& item_family = m_mesh.findFamily(itemKindArcaneToNeo(arcane_item_family->itemKind()),
                                            arcane_item_family->name().localstr());
      m_mesh.scheduleAddItems(item_family, std::vector<Int64>{ uids.begin(), uids.end() }, added_items);
      // ajouter les éléments Arcane
      auto& mesh_graph = m_mesh.internalMeshGraph();
      item_family.addMeshScalarProperty<Neo::utils::Int32>(PolyhedralFamily::m_arcane_item_lids_property_name.localstr());
      // copier les uids et les propriétaires pour les envoyer à Neo
      UniqueArray<Int64> uids_copy(uids);
      UniqueArray<Int32> owners_copy(owners);
      mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ item_family, item_family.lidPropName() },
                              Neo::MeshKernel::OutProperty{ item_family, PolyhedralFamily::m_arcane_item_lids_property_name.localstr() },
                              "AddArcaneItems"+std::string{arcane_item_family->name().localstr()},
                              [arcane_item_family, uids_local=std::move(uids_copy), &added_items, owners_local=std::move(owners_copy)]
                                  ([[maybe_unused]] Neo::ItemLidsProperty const& lids_property,
                                   Neo::MeshScalarPropertyT<Neo::utils::Int32>&) {
                                auto new_items_lids{added_items.new_items.localIds()};
                                Int32ConstSpan neo_items{ new_items_lids.data(), static_cast<Int32>(new_items_lids.size()) };
                                UniqueArray<Int32> arcane_items(added_items.new_items.size());
                                if (owners_local.empty())
                                  arcane_item_family->addItems(uids_local, arcane_items);
                                else
                                  arcane_item_family->addItems(uids_local, arcane_items, Int32ConstArrayView{ owners_local.size(), owners_local.data() });
                                // vérification de débogage de la correspondance des lids.
                                if (!arcane_items.size() == added_items.new_items.size())
                                  arcane_item_family->traceMng()->fatal() << "Inconsistent item lids generation between Arcane and Neo, nb items Neo "
                                  << added_items.new_items.size() << " nb items Arcane " << arcane_items.size();
                                if (!std::equal(added_items.new_items.begin(), added_items.new_items.end(), arcane_items.begin())) {
                                  arcane_item_family->traceMng()->info() << "Arcane Items " << arcane_items;
                                  std::cout << "Neo Items ";
                                  std::ranges::copy(neo_items,std::ostream_iterator<int>(std::cout," "));
                                  std::cout << "\n";
                                  arcane_item_family->traceMng()->fatal() << "Inconsistent item lids generation between Arcane and Neo in ItemFamily " << arcane_item_family->name();
                                }
                              });
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleRemoveItems(PolyhedralFamily* arcane_item_family,
                             Int32ConstArrayView local_ids)
    {
      auto& item_family = m_mesh.findFamily(itemKindArcaneToNeo(arcane_item_family->itemKind()),
                                            arcane_item_family->name().localstr());
      Neo::ItemRange removed_items{ Neo::ItemLocalIds{ { local_ids.begin(), local_ids.end() }, 0, 0 } };
      m_mesh.scheduleRemoveItems(item_family, removed_items);
      // Suppression des éléments Arcane
      auto& mesh_graph = m_mesh.internalMeshGraph();
      item_family.addMeshScalarProperty<Neo::utils::Int32>(PolyhedralFamily::m_arcane_remove_item_property_name.localstr());
      mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ item_family, m_mesh._removeItemPropertyName(item_family) },
                              Neo::MeshKernel::OutProperty{ item_family, PolyhedralFamily::m_arcane_remove_item_property_name.localstr() },
                              "RemoveArcaneFamily"+std::string{arcane_item_family->name().localstr()},
                              [arcane_item_family, local_ids](Neo::MeshScalarPropertyT<Neo::utils::Int32> const&,
                                                              Neo::MeshScalarPropertyT<Neo::utils::Int32>&) {
                                arcane_item_family->removeItems(local_ids);
                              });
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleAddConnectivity(PolyhedralFamily* arcane_source_item_family,
                                 PolyhedralTools::ItemLocalIds& source_items,
                                 Integer nb_connected_items_per_item,
                                 PolyhedralFamily* arcane_target_item_family,
                                 Int64ConstArrayView target_items_uids,
                                 String const& name)
    {
      // ajouter la connectivité dans Neo
      _scheduleAddConnectivity(arcane_source_item_family,
                               source_items,
                               nb_connected_items_per_item,
                               arcane_target_item_family,
                               target_items_uids,
                               name);
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleAddConnectivity(PolyhedralFamily* arcane_source_item_family,
                                 PolyhedralTools::ItemLocalIds& source_items,
                                 Int32ConstSmallSpan nb_connected_items_per_item,
                                 PolyhedralFamily* arcane_target_item_family,
                                 Int64ConstSmallSpan target_items_uids,
                                 String const& connectivity_name)
    {
      // ajouter la connectivité dans Neo
      _scheduleAddConnectivity(arcane_source_item_family,
                               source_items,
                               std::vector<Int32>{ nb_connected_items_per_item.begin(), nb_connected_items_per_item.end() },
                               arcane_target_item_family,
                               target_items_uids,
                               connectivity_name);
    }
 
    /*---------------------------------------------------------------------------*/
    /*---------------------------------------------------------------------------*/
 
    void scheduleUpdateConnectivity(PolyhedralFamily* arcane_source_item_family,
                                    PolyhedralTools::ItemLocalIds& source_items,
                                    Integer nb_connected_items_per_item,
                                    PolyhedralFamily* arcane_target_item_family,
                                    Int64ConstArrayView target_items_uids,
                                    String const& name)
    {
      // ajouter la connectivité dans Neo
      _scheduleAddConnectivity(arcane_source_item_family,
                               source_items,
                               nb_connected_items_per_item,
                               arcane_target_item_family,
                               target_items_uids,
                               name,
                               Neo::Mesh::ConnectivityOperation::Modify);
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleUpdateConnectivity(PolyhedralFamily* arcane_source_item_family,
                                    PolyhedralTools::ItemLocalIds& source_items,
                                    Int32ConstSmallSpan nb_connected_items_per_item,
                                    PolyhedralFamily* arcane_target_item_family,
                                    Int64ConstSmallSpan target_items_uids,
                                    String const& connectivity_name)
    {
      _scheduleAddConnectivity(arcane_source_item_family,
                               source_items,
                               std::vector<Int32>{ nb_connected_items_per_item.begin(), nb_connected_items_per_item.end() },
                               arcane_target_item_family,
                               target_items_uids,
                               connectivity_name,
                               Neo::Mesh::ConnectivityOperation::Modify);
    }
 
    /*---------------------------------------------------------------------------*/
 
    // template to handle nb_items_per_item type (an int or an array)
    template <typename ConnectivitySizeType>
    void _scheduleAddConnectivity(PolyhedralFamily* arcane_source_item_family,
                                  PolyhedralTools::ItemLocalIds& source_items,
                                  ConnectivitySizeType&& nb_connected_items_per_item,
                                  PolyhedralFamily* arcane_target_item_family,
                                  Int64ConstSmallSpan target_item_uids,
                                  String const& connectivity_name,
                                  Neo::Mesh::ConnectivityOperation operation = Neo::Mesh::ConnectivityOperation::Add)
    {
      // ajouter la connectivité dans Neo
      auto& source_family = m_mesh.findFamily(itemKindArcaneToNeo(arcane_source_item_family->itemKind()),
                                              arcane_source_item_family->name().localstr());
      auto& target_family = m_mesh.findFamily(itemKindArcaneToNeo(arcane_target_item_family->itemKind()),
                                              arcane_target_item_family->name().localstr());
      // Copier les données pour les envoyer à Neo
      UniqueArray<Int64> target_item_uids_copy(target_item_uids);
      // Supprimer les connectivités avec un élément nul
      std::vector<Int64> target_item_uids_filtered;
      target_item_uids_filtered.reserve(target_item_uids.size());
      std::copy_if(target_item_uids.begin(),
                   target_item_uids.end(),
                   std::back_inserter(target_item_uids_filtered),
                   [](auto uid) { return uid != NULL_ITEM_UNIQUE_ID; });
      // Ajouter la connectivité dans Neo (asynchrone)
      m_mesh.scheduleAddConnectivity(source_family, source_items.m_future_items, target_family,
                                     std::forward<ConnectivitySizeType>(nb_connected_items_per_item),
                                     std::move(target_item_uids_filtered),
                                     connectivity_name.localstr(),
                                     operation);
      // Enregistrer les connectivités Neo dans Arcane
      auto& mesh_graph = m_mesh.internalMeshGraph();
      std::string connectivity_add_output_property_name = std::string{ "EndOf" } + connectivity_name.localstr() + "Add";
      source_family.addScalarProperty<Neo::utils::Int32>(connectivity_add_output_property_name);
      // TODO si operation == Modify, l'algo de mise à jour ne devrait pas être nécessaire. À vérifier
      mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ source_family, connectivity_name.localstr() },
                              Neo::MeshKernel::OutProperty{ source_family, connectivity_add_output_property_name },
                              "UpdateArcaneConnectivity"+std::string{connectivity_name.localstr()},
                              [arcane_source_item_family, arcane_target_item_family, &source_family, &target_family, this]
                                    (Neo::Mesh::ConnectivityPropertyType const& neo_connectivity,
                                     Neo::ScalarPropertyT<Neo::utils::Int32>&) {
                                auto rank = arcane_source_item_family->mesh()->parallelMng()->commRank();
                                Neo::printer(rank) << "==Algorithm update Arcane connectivity: "<< neo_connectivity.name() << Neo::endline;
                                auto item_internal_connectivity_list = arcane_source_item_family->itemInternalConnectivityList();
                                // todo check if families are default families
                                auto connectivity = m_mesh.getConnectivity(source_family, target_family, neo_connectivity.name());
                                // to access connectivity data (for initializing Arcane connectivities) create a proxy on Neo connectivity
                                auto& connectivity_values = source_family.getConcreteProperty<Neo::Mesh::ConnectivityPropertyType>(neo_connectivity.name());
                                Neo::MeshArrayPropertyProxyT<Neo::Mesh::ConnectivityPropertyType::PropertyDataType> connectivity_proxy{ connectivity_values };
                                auto nb_item_data = connectivity_proxy.arrayPropertySizes();
                                auto nb_item_size = connectivity_proxy.arrayPropertySizesSize();
                                item_internal_connectivity_list->_setConnectivityNbItem(arcane_target_item_family->itemKind(),
                                                                                        Int32ArrayView{ Integer(nb_item_size), nb_item_data });
                                auto max_nb_connected_items = connectivity.maxNbConnectedItems();
                                item_internal_connectivity_list->_setMaxNbConnectedItem(arcane_target_item_family->itemKind(), max_nb_connected_items);
                                auto connectivity_values_data = connectivity_proxy.arrayPropertyData();
                                auto connectivity_values_size = connectivity_proxy.arrayPropertyDataSize();
                                item_internal_connectivity_list->_setConnectivityList(arcane_target_item_family->itemKind(),
                                                                                      Int32ArrayView{ Integer(connectivity_values_size), connectivity_values_data });
                                auto connectivity_index_data = connectivity_proxy.arrayPropertyIndex();
                                auto connectivity_index_size = connectivity_proxy.arrayPropertyIndexSize();
                                item_internal_connectivity_list->_setConnectivityIndex(arcane_target_item_family->itemKind(),
                                                                                       Int32ArrayView{ Integer(connectivity_index_size), connectivity_index_data }); }, Neo::MeshKernel::AlgorithmPropertyGraph::AlgorithmPersistence::KeepAfterExecution);
      // Si FaceToCellConnectivity Ajouter les drapeaux de face II_Boundary, II_SubdomainBoundary, II_HasFrontCell, II_HasBackCell
      if (arcane_source_item_family->itemKind() == IK_Face && arcane_target_item_family->itemKind() == IK_Cell) {
        std::string flag_definition_output_property_name{ "EndOfFlagDefinition" };
        source_family.addScalarProperty<Neo::utils::Int32>(flag_definition_output_property_name);
        // mettre à jour les drapeaux de face après l'ajout de connectivité
        mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ source_family, connectivity_add_output_property_name }, Neo::MeshKernel::OutProperty{ source_family, flag_definition_output_property_name },
                                "UpdateFaceFlagsAfterConnectivityDefinition",
                                [arcane_source_item_family, arcane_target_item_family, target_item_uids_local = std::move(target_item_uids_copy), &source_items](Neo::ScalarPropertyT<Neo::utils::Int32> const&, Neo::ScalarPropertyT<Neo::utils::Int32> const&) {
                                  auto current_face_index = 0;
                                  auto arcane_faces = arcane_source_item_family->itemInfoListView();
                                  Int32UniqueArray target_item_lids(target_item_uids_local.size());
                                  arcane_target_item_family->itemsUniqueIdToLocalId(target_item_lids, target_item_uids_local, false);
                                  for (auto face_lid : source_items.m_future_items.new_items) {
                                    Face current_face = arcane_faces[face_lid].toFace();
                                    if (target_item_lids[2 * current_face_index + 1] == NULL_ITEM_LOCAL_ID) {
                                      // Seulement maille arrière ou aucune
                                      Int32 mod_flags = (target_item_lids[2 * current_face_index] != NULL_ITEM_LOCAL_ID) ? (ItemFlags::II_Boundary | ItemFlags::II_HasBackCell | ItemFlags::II_BackCellIsFirst) : 0;
                                      _setFaceInfos(mod_flags, current_face);
                                    }
                                    else if (target_item_lids[2 * current_face_index] == NULL_ITEM_LOCAL_ID) {
                                      // Seulement maille avant ou aucune
                                      _setFaceInfos(ItemFlags::II_Boundary | ItemFlags::II_HasFrontCell | ItemFlags::II_FrontCellIsFirst, current_face);
                                    }
                                    else {
                                      // Maille avant et arrière
                                      _setFaceInfos(ItemFlags::II_HasFrontCell | ItemFlags::II_HasBackCell | ItemFlags::II_BackCellIsFirst, current_face);
                                    }
                                    ++current_face_index;
                                  }
                                });
        // Ajouter un algorithme pour mettre à jour les drapeaux de face lorsqu'une maille connectée est supprimée
        auto const isolated_items_property_name = m_mesh._isolatedItemLidsPropertyName(source_family,target_family);
        std::string const flag_update_output_property_name{ "EndOfFlagUpdate" };
        source_family.addScalarProperty<Neo::utils::Int32>(flag_update_output_property_name);
 
        mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ source_family, isolated_items_property_name },
                                Neo::MeshKernel::OutProperty{ source_family, flag_update_output_property_name },
                                "UpdateFaceFlagsAfterCellRemoval",
                                [arcane_source_item_family,&source_family,connectivity_name](Neo::MeshScalarPropertyT<Neo::utils::Int32> const&, Neo::ScalarPropertyT<Neo::utils::Int32> const&) {
                                  auto const rank = arcane_source_item_family->mesh()->parallelMng()->commRank();
                                  Neo::printer(rank) << "==Algorithm update Face flags after cell removal" << Neo::endline;
                                  // TODO devrait être une propriété d'entrée
                                  auto const removed_target_item_index_prop_name = Neo::Mesh::removedTargetItemIndexfilteredItemPropertyName(connectivity_name.localstr());
                                  auto& null_item_connected = source_family.getConcreteProperty<Neo::MeshArrayPropertyT<Neo::utils::Int32>>(removed_target_item_index_prop_name);
                                  null_item_connected.debugPrint(rank);
                                  ENUMERATE_(Face,iface,arcane_source_item_family->allItems())
                                  {
                                    Face current_face = *iface;
                                    auto null_items_connected_to_face = null_item_connected[iface.localId()];
                                    if (null_items_connected_to_face.size() > 2)
                                    {
                                      ARCANE_FATAL("More than one null item connected to face {0}",iface.localId());
                                    }
                                    // Si aucune maille n'est supprimée, rien à faire
                                    if (null_items_connected_to_face.size() == 0)
                                      continue;
                                    // S'il n'y a qu'une seule maille, vérifier si l'arrière ou l'avant subsiste
                                    // L'avant de la maille subsiste
                                    if (null_items_connected_to_face[0] == 0)
                                    {
                                      _setFaceInfos(ItemFlags::II_Boundary|ItemFlags::II_SubDomainBoundary|
                                        ItemFlags::II_HasFrontCell|ItemFlags::II_FrontCellIsFirst,current_face);
                                    }
                                    else if (null_items_connected_to_face[0] == 1)
                                    {
                                      _setFaceInfos(ItemFlags::II_Boundary|ItemFlags::II_SubDomainBoundary|
                                        ItemFlags::II_HasBackCell|ItemFlags::II_BackCellIsFirst,current_face);
                                    }
                                  }
 
                                },
                                Neo::MeshKernel::AlgorithmPropertyGraph::AlgorithmPersistence::KeepAfterExecution
        );
      }
      // Ajouter un algorithme pour supprimer les éléments isolés après une mise à jour de connectivité. L'ajouter une seule fois, lors de l'ajout de la connectivité
      if (operation == Neo::Mesh::ConnectivityOperation::Modify)
        return;
      auto isolated_item_property_name = m_mesh._isolatedItemLidsPropertyName(source_family, target_family);
      auto end_of_isolated_removal_property_name = std::string{ "EndOf" } + isolated_item_property_name;
      source_family.addScalarProperty<Neo::utils::Int32>(end_of_isolated_removal_property_name);
      mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ source_family, isolated_item_property_name },
        Neo::MeshKernel::OutProperty{ source_family, end_of_isolated_removal_property_name },
        "RemoveIsolatedArcaneItemsIn"+std::string{ arcane_source_item_family->name().localstr() },
        [arcane_source_item_family](Neo::MeshScalarPropertyT<Neo::utils::Int32> const& isolated_items_lids_property,
          Neo::ScalarPropertyT<Neo::utils::Int32>& end_of_isolated_removal_property) {
          end_of_isolated_removal_property.set(1);
          // supprimer les éléments Arcane
          Int32UniqueArray isolated_item_lids;
          isolated_item_lids.reserve(isolated_items_lids_property.size());
          ENUMERATE_(Item,iitem,arcane_source_item_family->allItems()) {
            if (isolated_items_lids_property[iitem->localId()] == 1) {
              isolated_item_lids.push_back(iitem->localId());
            }
          }
          std::sort(isolated_item_lids.begin(), isolated_item_lids.end());
          arcane_source_item_family->traceMng()->info() << "Remove isolated in Arcane for family "
            << arcane_source_item_family->name() << " lids : " << isolated_item_lids;
            isolated_items_lids_property.debugPrint();
          arcane_source_item_family->removeItems(isolated_item_lids);
        }, Neo::MeshKernel::AlgorithmPropertyGraph::AlgorithmPersistence::KeepAfterExecution);
    }
 
    /*---------------------------------------------------------------------------*/
 
    void scheduleSetItemCoordinates(PolyhedralFamily* item_family, PolyhedralTools::ItemLocalIds& local_ids, Real3ConstSmallSpan item_coords, VariableItemReal3& arcane_coords)
    {
      auto& _item_family = m_mesh.findFamily(itemKindArcaneToNeo(item_family->itemKind()), item_family->name().localstr());
      std::vector<Neo::utils::Real3> _node_coords(item_coords.size());
      auto node_index = 0;
      for (auto&& node_coord : item_coords) {
        _node_coords[node_index++] = Neo::utils::Real3{ node_coord.x, node_coord.y, node_coord.z };
      }
      m_mesh.scheduleSetItemCoords(_item_family, local_ids.m_future_items, _node_coords);
      // Remplir la variable Arcane
      auto& mesh_graph = m_mesh.internalMeshGraph();
      _item_family.addScalarProperty<Int32>("NoOutProperty42"); // todo supprimer : créer un algo sans sortie dans Neo
      mesh_graph.addAlgorithm(Neo::MeshKernel::InProperty{ _item_family, m_mesh._itemCoordPropertyName(_item_family) },
                              Neo::MeshKernel::OutProperty{ _item_family, "NoOutProperty42" },
                              "UpdateArcaneCoordsIn"+std::string{item_family->name().localstr()},
                              [this, item_family, &_item_family, &arcane_coords](Neo::Mesh::CoordPropertyType const& item_coords_property,
                                                                                 Neo::ScalarPropertyT<Neo::utils::Int32>&) {
                                // enumerate nodes : ensure again Arcane/Neo local_ids are identicals
                                auto& all_items = _item_family.all();
                                VariableNodeReal3 node_coords{ VariableBuildInfo{ item_family->mesh(), "NodeCoord" } };
                                for (auto item : all_items) {
                                  arcane_coords[ItemLocalId{ item }] = { item_coords_property[item].x,
                                                                         item_coords_property[item].y,
                                                                         item_coords_property[item].z };
                                }
                              });
    }
 
    /*---------------------------------------------------------------------------*/
 
    Neo::EndOfMeshUpdate applyScheduledOperations() noexcept
    {
      return m_mesh.applyScheduledOperations();
    }
  };
 
  template <> class PolyhedralMeshImpl::ItemKindTraits<IK_Cell>
  {
    static const Neo::ItemKind item_kind = Neo::ItemKind::IK_Cell;
  };
  template <> class PolyhedralMeshImpl::ItemKindTraits<IK_Face>
  {
    static const Neo::ItemKind item_kind = Neo::ItemKind::IK_Face;
  };
  template <> class PolyhedralMeshImpl::ItemKindTraits<IK_Edge>
  {
    static const Neo::ItemKind item_kind = Neo::ItemKind::IK_Edge;
  };
  template <> class PolyhedralMeshImpl::ItemKindTraits<IK_Node>
  {
    static const Neo::ItemKind item_kind = Neo::ItemKind::IK_Node;
  };
  template <> class PolyhedralMeshImpl::ItemKindTraits<IK_DoF>
  {
    static const Neo::ItemKind item_kind = Neo::ItemKind::IK_Dof;
  };
 
  /*---------------------------------------------------------------------------*/
 
  void PolyhedralFamilySerializer::serializeItems(ISerializer* buf, Int32ConstArrayView items_local_ids)
  {
    ARCANE_CHECK_POINTER(m_family);
    ARCANE_CHECK_POINTER(m_mng);
 
    switch (buf->mode()) {
    case ISerializer::ModeReserve: {
      _fillItemData(items_local_ids);
      m_item_data.serialize(buf);
      auto connectivities = m_mesh->_impl()->connectivities(m_family);
      for (auto out_connectivity : connectivities) {
        buf->reserve(out_connectivity.target_family.name());
        buf->reserve(out_connectivity.name);
      }
      break;
    }
    case ISerializer::ModePut: {
      m_item_data.serialize(buf);
      auto connectivities = m_mesh->_impl()->connectivities(m_family);
      for (auto out_connectivity : connectivities) {
        buf->put(out_connectivity.target_family.name());
        buf->put(out_connectivity.name);
      }
      clear();
      break;
    }
    case ISerializer::ModeGet: {
      deserializeItems(buf, nullptr);
      break;
    }
    }
  }
 
  /*---------------------------------------------------------------------------*/
 
  void PolyhedralFamilySerializer::deserializeItems(ISerializer* buf, Int32Array* items_local_ids)
  {
    ARCANE_ASSERT((buf->mode() == ISerializer::ModeGet),
                  ("Impossible to deserialize a buffer not in ModeGet. In ItemData::deserialize.Exiting"))
    ARCANE_CHECK_POINTER(m_mesh);
    ARCANE_CHECK_POINTER(m_family);
    ARCANE_CHECK_POINTER(m_mng);
    ItemData item_data;
    if (items_local_ids)
      item_data.deserialize(buf, m_mesh, *items_local_ids);
    else
      item_data.deserialize(buf, m_mesh);
    auto connectivities = m_mesh->_impl()->connectivities(m_family);
    auto nb_connectivities = connectivities.size();
    StringUniqueArray connected_family_names(nb_connectivities);
    StringUniqueArray connectivity_names(nb_connectivities);
    auto index = 0;
    for (auto out_connectivity : connectivities) {
      buf->get(connected_family_names[index]);
      buf->get(connectivity_names[index]);
      ++index;
    }
    _fillItemFamilyInfo(item_data, connected_family_names, connectivity_names);
 
    if (items_local_ids) {
      m_deserialized_lids_array.push_back(items_local_ids);
      // and that's all, they will be filled in finalizeItemAllocation
    }
    m_future_item_lids_array.push_back(std::make_shared<PolyhedralTools::ItemLocalIds>());
    m_mesh->scheduleAllocateItems(m_family_info, *m_future_item_lids_array.back().get());
 
    // Add serializer in mng. Update is triggered when finalizeItemAllocation is called
    m_mng->addSerializer(this);
  }
 
  /*---------------------------------------------------------------------------*/
  void PolyhedralFamilySerializer::_fillItemData(Int32ConstArrayView items_local_ids)
  {
    m_item_data = ItemData{ items_local_ids.size(), 0, m_family, nullptr, m_family->parallelMng()->commRank() };
    Int64Array& item_infos = m_item_data.itemInfos();
    Int32ArrayView item_owners = m_item_data.itemOwners();
    // Réserver la taille
    const Integer nb_item = items_local_ids.size();
    item_infos.reserve(1 + nb_item * 32); // Size evaluation for hexa cell (the more data to store) : 1_family_info + nb_item *(2_info_per_family + 6 (faces) + 12 (edges) + 8 (vertices) connected elements) = 1 + nb_item *(6 + 6 + 12 +8)
    // Remplir les données des éléments (cf ItemData.h)
    PolyhedralMeshImpl* mesh_impl = m_mesh->_impl();
    auto connectivities = mesh_impl->connectivities(m_family);
    item_infos.add(connectivities.size());
    bool is_face_family = m_family->itemKind() == IK_Face;
    ENUMERATE_ITEM (item, m_family->view(items_local_ids)) {
      item_infos.add(42); // Item type, not used for polyhedral mesh
      item_infos.add(item->uniqueId().asInt64());
      item_owners[item.index()] = item->owner();
      for (auto out_connectivity : connectivities) {
        auto target_family = m_mesh->findItemFamily(PolyhedralMeshImpl::itemKindNeoToArcane(out_connectivity.target_family.itemKind()),
                                                    out_connectivity.target_family.name(), false, false);
        // auto arcane_connected_items = target_family->view();
        auto arcane_connected_items = target_family->itemInfoListView();
        bool is_face_cell_connection = is_face_family && target_family->itemKind() == IK_Cell;
        item_infos.add(PolyhedralMeshImpl::itemKindNeoToArcane(out_connectivity.target_family.itemKind()));
        auto connected_items = out_connectivity[item.localId()];
        auto nb_connected_items = connected_items.size();
        item_infos.add(nb_connected_items);
        if (is_face_cell_connection && item->itemBase().isBoundary() && item->itemBase().backCell().isNull()) {
          item_infos.add(NULL_ITEM_UNIQUE_ID);
        }
        for (auto connected_item_lid : connected_items) {
          item_infos.add(arcane_connected_items[connected_item_lid].uniqueId().asInt64());
        }
        if (is_face_cell_connection && item->itemBase().isBoundary() && !item->itemBase().backCell().isNull()) {
          item_infos.add(NULL_ITEM_UNIQUE_ID);
        }
      }
    }
  }
 
} // End namespace mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class mesh::PolyhedralMesh::PolyhedralMeshModifier
: public IPolyhedralMeshModifier
{
 public:
 
  explicit PolyhedralMeshModifier(PolyhedralMesh* mesh)
  : m_mesh(mesh)
  {}
 
  void addItems(Int64ConstArrayView unique_ids, Int32ArrayView local_ids, eItemKind ik, const String& family_name) override
  {
    m_mesh->addItems(unique_ids, local_ids, ik, family_name);
  }
 
  void addItems(Int64ConstArrayView unique_ids, Int32ArrayView local_ids, Int32ConstArrayView owners, eItemKind ik, const String& family_name) override
  {
    m_mesh->addItems(unique_ids, local_ids, owners, ik, family_name);
  }
 
  void removeItems(Int32ConstArrayView local_ids, eItemKind ik, const String& family_name) override
  {
    m_mesh->removeItems(local_ids, ik, family_name);
  }
 
 private:
 
  PolyhedralMesh* m_mesh;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class mesh::PolyhedralMesh::InternalApi
: public IMeshInternal
, public IMeshModifierInternal
{
 public:
 
  explicit InternalApi(PolyhedralMesh* mesh)
  : m_mesh(mesh)
  , m_connectivity_mng(std::make_unique<ItemConnectivityMng>(mesh->traceMng()))
  , m_polyhedral_mesh_modifier(std::make_unique<PolyhedralMeshModifier>(mesh))
  {}
 
 public:
 
  void setMeshKind(const MeshKind& v) override
  {
    if (v.meshStructure() != eMeshStructure::Polyhedral && v.meshAMRKind() != eMeshAMRKind::None) {
      ARCANE_FATAL("Incompatible mesh structure ({0}) and amr kind ({1}) for Polyhedral mesh {2}. Must be (Polyhedral,None). ",
                   v.meshStructure(), v.meshAMRKind(), m_mesh->name());
    }
    m_mesh->m_mesh_kind = v;
  }
 
  IItemConnectivityMng* dofConnectivityMng() const noexcept override
  {
    return m_connectivity_mng.get();
  }
 
  IPolyhedralMeshModifier* polyhedralMeshModifier() const noexcept override
  {
    return m_polyhedral_mesh_modifier.get();
  }
 
  void removeNeedRemoveMarkedItems() override
  {
    m_mesh->removeNeedRemoveMarkedItems();
  }
  NodeLocalId addNode([[maybe_unused]] ItemUniqueId unique_id) override
  {
    ARCANE_THROW(NotImplementedException, "");
  }
  FaceLocalId addFace([[maybe_unused]] ItemUniqueId unique_id,
                      [[maybe_unused]] ItemTypeId type_id,
                      [[maybe_unused]] ConstArrayView<Int64> nodes_uid) override
  {
    ARCANE_THROW(NotImplementedException, "");
  }
  CellLocalId addCell([[maybe_unused]] ItemUniqueId unique_id,
                      [[maybe_unused]] ItemTypeId type_id,
                      [[maybe_unused]] ConstArrayView<Int64> nodes_uid) override
  {
    ARCANE_THROW(NotImplementedException, "");
  }
 
  IItemFamilySerializerMngInternal* familySerializerMng() const noexcept override
  {
    return m_mesh->polyhedralFamilySerializerMng();
  }
 
 private:
 
  PolyhedralMesh* m_mesh = nullptr;
  std::unique_ptr<IItemConnectivityMng> m_connectivity_mng = nullptr;
  std::unique_ptr<IPolyhedralMeshModifier> m_polyhedral_mesh_modifier = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class mesh::PolyhedralMesh::NoCompactionMeshCompacter
: public IMeshCompacter
{
 public:
 
  explicit NoCompactionMeshCompacter(PolyhedralMesh* mesh)
  : m_mesh(mesh)
  , m_trace_mng(mesh->traceMng())
  {}
 
  void doAllActions() override { _info(); };
 
  void beginCompact() override { _info(); };
  void compactVariablesAndGroups() override { _info(); };
  void updateInternalReferences() override { _info(); };
  void endCompact() override { _info(); };
  void finalizeCompact() override { _info(); };
 
  IMesh* mesh() const override { return m_mesh; };
 
  const ItemFamilyCompactInfos* findCompactInfos(IItemFamily*) const override
  {
    _info();
    return nullptr;
  }
 
  ePhase phase() const override
  {
    _info();
    return ePhase::Ended;
  }
 
  void setSorted(bool) override { _info(); };
 
  bool isSorted() const override
  {
    _info();
    return false;
  };
 
  ItemFamilyCollection families() const override
  {
    _info();
    return ItemFamilyCollection{};
  };
 
  void _setCompactVariablesAndGroups(bool) override { _info(); };
 
 private:
 
  PolyhedralMesh* m_mesh = nullptr;
  ITraceMng* m_trace_mng = nullptr;
 
  void _info() const { m_trace_mng->info() << A_FUNCINFO << "No compacting in PolyhedralMesh"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class mesh::PolyhedralMesh::NoCompactionMeshCompactMng
: public IMeshCompactMng
{
 public:
 
  explicit NoCompactionMeshCompactMng(PolyhedralMesh* mesh)
  : m_mesh(mesh)
  , m_trace_mng(mesh->traceMng())
  , m_mesh_compacter{ std::make_unique<NoCompactionMeshCompacter>(m_mesh) }
  {}
 
  IMesh* mesh() const override { return m_mesh; }
  IMeshCompacter* beginCompact() override
  {
    _info();
    return m_mesh_compacter.get();
  }
 
  IMeshCompacter* beginCompact(IItemFamily* family) override
  {
    ARCANE_UNUSED(family);
    _info();
    return m_mesh_compacter.get();
  };
 
  void endCompact() override { _info(); };
 
  IMeshCompacter* compacter() override
  {
    _info();
    return m_mesh_compacter.get();
  };
 
 private:
 
  PolyhedralMesh* m_mesh = nullptr;
  ITraceMng* m_trace_mng = nullptr;
  std::unique_ptr<IMeshCompacter> m_mesh_compacter = nullptr;
 
  void _info() const { m_trace_mng->info() << A_FUNCINFO << "No compacting in PolyhedralMesh"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralMesh::
~PolyhedralMesh()
{
  m_mesh_handle._setMesh(nullptr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ITraceMng* mesh::PolyhedralMesh::
traceMng()
{
  return m_subdomain->traceMng();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle mesh::PolyhedralMesh::
handle() const
{
  return m_mesh_handle;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
mesh::PolyhedralMesh::
PolyhedralMesh(ISubDomain* subdomain, const MeshBuildInfo& mbi)
: EmptyMesh{ subdomain->traceMng() }
, m_name{ mbi.name() }
, m_subdomain{ subdomain }
, m_mesh_handle{ m_subdomain->defaultMeshHandle() }
, m_properties(std::make_unique<Properties>(subdomain->propertyMng(), String("ArcaneMeshProperties_") + m_name))
, m_mesh{ std::make_unique<mesh::PolyhedralMeshImpl>(m_subdomain) }
, m_parallel_mng{ mbi.parallelMngRef().get() }
, m_mesh_part_info{ makeMeshPartInfoFromParallelMng(m_parallel_mng) }
, m_item_type_mng(ItemTypeMng::_singleton())
, m_mesh_kind(mbi.meshKind())
, m_polyhedral_family_serializer_mng{ std::make_unique<PolyhedralFamilySerializerMng>(this) }
, m_initial_allocator(*this)
, m_variable_mng{ subdomain->variableMng() }
, m_mesh_checker{ this }
, m_internal_api{ std::make_unique<InternalApi>(this) }
, m_compact_mng{ std::make_unique<NoCompactionMeshCompactMng>(this) }
, m_mesh_utilities{ std::make_unique<UnstructuredMeshUtilities>(this) }
, m_mesh_exchange_mng{ std::make_unique<MeshExchangeMng>(this) }
, m_item_family_network{ std::make_unique<ItemFamilyNetwork>(m_trace_mng) }
, m_ghost_layer_mng{ std::make_unique<GhostLayerMng>(m_trace_mng) }
, m_connectivity(VariableBuildInfo{ subdomain, mbi.name() + "MeshConnectivity" })
{
  m_mesh_handle._setMesh(this);
  m_mesh_item_internal_list.mesh = this;
  m_default_arcane_families.fill(nullptr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
allocateItems(const Arcane::ItemAllocationInfo& item_allocation_info)
{
  _allocateItems(item_allocation_info, ArrayView<Int32UniqueArray>{});
}
 
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
allocateItems(const Arcane::ItemAllocationInfo& item_allocation_info, ArrayView<Int32UniqueArray> family_lids)
{
  _allocateItems(item_allocation_info, family_lids);
}
 
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_allocateItems(const Arcane::ItemAllocationInfo& item_allocation_info, ArrayView<Int32UniqueArray> family_lids)
{
  // Deuxième étape : lecture d'un maillage polyédrique vtk
  m_subdomain->traceMng()->info() << "--PolyhedralMesh: allocate items --";
  UniqueArray<PolyhedralTools::ItemLocalIds> item_local_ids(item_allocation_info.family_infos.size());
  auto family_index = 0;
  // Préparation de la création des éléments
  for (auto& family_info : item_allocation_info.family_infos) {
    bool create_if_needed = true;
    auto* item_family = _findItemFamily(family_info.item_kind, family_info.name, create_if_needed);
    m_trace_mng->debug(Trace::High) << "- Création des éléments " << family_info.name;
    m_mesh->scheduleAddItems(item_family, family_info.item_uids, family_info.item_owners.constSmallSpan(), item_local_ids[family_index++]);
  }
  // Préparation de la création des connectivités
  family_index = 0;
  for (auto& family_info : item_allocation_info.family_infos) {
    auto* item_family = _findItemFamily(family_info.item_kind, family_info.name);
    m_trace_mng->debug(Trace::High) << "- Famille actuelle " << family_info.name;
    for (auto& current_connected_family_info : family_info.connected_family_infos) {
      auto connected_family = _findItemFamily(current_connected_family_info.item_kind, current_connected_family_info.name);
      m_trace_mng->debug(Trace::High) << "- Création de la connectivité " << current_connected_family_info.connectivity_name;
      // vérifier si la famille connectée existe
      if (!connected_family) {
        ARCANE_WARNING((String::format("Impossible de trouver la famille {0} avec le type {1} "
                                       "La connectivité entre {1} et cette famille est ignorée",
                                       current_connected_family_info.name,
                                       current_connected_family_info.item_kind,
                                       item_family->name())
                        .localstr()));
        continue;
      }
      m_mesh->scheduleAddConnectivity(item_family,
                                      item_local_ids[family_index],
                                      current_connected_family_info.nb_connected_items_per_item,
                                      connected_family,
                                      current_connected_family_info.connected_items_uids,
                                      current_connected_family_info.connectivity_name);
      Connectivity connectivity{ m_connectivity };
      connectivity.enableConnectivity(Connectivity::kindsToConnectivity(item_family->itemKind(), connected_family->itemKind()));
    }
    ++family_index;
  }
  // Création des éléments et des connectivités
  m_mesh->applyScheduledOperations();
  // Crée la variable pour les coordonnées. Cela doit être fait avant l'appel à family::endUpdate. À faire : ajouter au graphe
  for (auto& family_info : item_allocation_info.family_infos) {
    if (family_info.item_kind != IK_Node && family_info.item_coordinates.empty()) { // la variable est créée pour le nœud même s'il n'y a pas de coordonnées (parallèle)
      continue;
    }
    auto* item_family = _findItemFamily(family_info.item_kind, family_info.name);
    if (item_family == itemFamily(IK_Node)) { // crée les coordonnées des nœuds du maillage si elles n'existent pas
      if (!m_arcane_node_coords.get()) {
        m_arcane_node_coords = std::make_unique<VariableNodeReal3>(VariableBuildInfo(this, family_info.item_coordinates_variable_name));
        m_arcane_node_coords->setUsed(true);
      }
    }
    else {
      auto arcane_item_coords_var_ptr = std::make_unique<VariableItemReal3>(VariableBuildInfo(this, family_info.item_coordinates_variable_name),
                                                                            item_family->itemKind());
      arcane_item_coords_var_ptr->setUsed(true);
      m_arcane_item_coords.push_back(std::move(arcane_item_coords_var_ptr));
    }
  }
  // Appel de Arcane ItemFamily endUpdate
  for (auto& family : m_arcane_families) {
    family->endUpdate();
  }
  endUpdate();
  // Ajoute les coordonnées si nécessaire (nœuds, ou dof, ou particules...)
  family_index = 0;
  auto index = 0;
  for (auto& family_info : item_allocation_info.family_infos) {
    if (family_info.item_coordinates.empty()) {
      ++family_index;
      continue;
    }
    auto* item_family = _findItemFamily(family_info.item_kind, family_info.name);
    if (item_family == itemFamily(IK_Node)) { // coordonnées des nœuds du maillage
      m_mesh->scheduleSetItemCoordinates(item_family, item_local_ids[family_index], family_info.item_coordinates, *m_arcane_node_coords);
    }
    else
      m_mesh->scheduleSetItemCoordinates(item_family, item_local_ids[family_index], family_info.item_coordinates, *m_arcane_item_coords[index++].get());
  }
  auto mesh_state = m_mesh->applyScheduledOperations();
  m_is_allocated = true;
  // indique que le maillage contient des Mailles générales
  itemTypeMng()->setMeshWithGeneralCells(this);
 
  if (!family_lids.empty()) {
    auto index = 0;
    ARCANE_ASSERT((family_lids.size() == item_local_ids.size()), ("Incoherence in item number"));
    for (auto& lid_array : item_local_ids) {
      family_lids[index].resize(lid_array.size());
      lid_array.fillArrayView(family_lids[index].view(), mesh_state);
      ++index;
    }
  }
}
 
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
scheduleAllocateItems(const Arcane::ItemAllocationInfo::FamilyInfo& family_info, mesh::PolyhedralTools::ItemLocalIds& item_local_ids)
{
  // Deuxième étape : lecture d'un maillage polyédrique vtk
  m_subdomain->traceMng()->info() << "--PolyhedralMesh: schedule allocate items --";
  // Préparation de la création des éléments
  bool create_if_needed = true;
  auto* item_family = _findItemFamily(family_info.item_kind, family_info.name, create_if_needed);
  m_trace_mng->debug(Trace::High) << "- Famille actuelle " << family_info.name;
  m_trace_mng->debug(Trace::High) << "- Création des éléments ";
  m_mesh->scheduleAddItems(item_family, family_info.item_uids, family_info.item_owners.constSmallSpan(), item_local_ids);
  // Préparation de la création des connectivités
  for (auto& current_connected_family_info : family_info.connected_family_infos) {
    auto connected_family = _findItemFamily(current_connected_family_info.item_kind, current_connected_family_info.name);
    m_trace_mng->debug(Trace::High) << "- Création de la connectivité " << current_connected_family_info.connectivity_name;
    // vérifier si la famille connectée existe
    if (!connected_family) {
      ARCANE_WARNING((String::format("Impossible de trouver la famille {0} avec le type {1} "
                                     "La connectivité entre {1} et cette famille est ignorée",
                                     current_connected_family_info.name,
                                     current_connected_family_info.item_kind,
                                     item_family->name())
                      .localstr()));
      continue;
    }
    m_mesh->scheduleUpdateConnectivity(item_family,
                                       item_local_ids,
                                       current_connected_family_info.nb_connected_items_per_item,
                                       connected_family,
                                       current_connected_family_info.connected_items_uids,
                                       current_connected_family_info.connectivity_name);
  }
}
 
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
applyScheduledAllocateItems(UniqueArray<std::shared_ptr<PolyhedralTools::ItemLocalIds>> item_lids)
{
  // Création des éléments et des connectivités
  auto mesh_state = m_mesh->applyScheduledOperations();
  // Remplir item_lids (ils sont déjà remplis dans applyScheduledOperations : les déverrouiller en définissant mesh_state)
  for (auto item_local_ids : item_lids) {
    item_local_ids->m_mesh_state = std::make_shared<Neo::EndOfMeshUpdate>(mesh_state);
  }
 
  // Appel de Arcane ItemFamily endUpdate et de la mise à jour finale du maillage
  for (auto& family : m_arcane_families) {
    family->endUpdate();
  }
  endUpdate();
  m_is_allocated = true;
  // indique que le maillage contient des Mailles générales
  itemTypeMng()->setMeshWithGeneralCells(this);
}
 
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::removeNeedRemoveMarkedItems()
{
  // Parcourir toutes les familles d'éléments dans le maillage : doit inclure DoF et Particules
  for (auto family_index = 0; family_index < m_arcane_families.size(); ++family_index) {
    // Obtenir la liste des IDs locaux des éléments à supprimer
    auto* family = m_arcane_families[family_index].get();
    Int32UniqueArray items_to_remove;
    items_to_remove.reserve(family->nbItem());
    auto& items_map = family->itemsMap();
    if (items_map.count() == 0)
      continue;
    items_map.eachItem([&](ItemBase item) {
      // Planifier la suppression des éléments marqués pour suppression
      auto f = item.flags();
      if (f & ItemFlags::II_NeedRemove) {
        f &= ~ItemFlags::II_NeedRemove & ItemFlags::II_Suppressed;
        item.toMutable().setFlags(f);
        items_to_remove.add(item.localId());
      }
    });
    if (!items_to_remove.empty()) {
      removeItems(items_to_remove, family);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
 
Arcane::mesh::PolyhedralFamilySerializerMng* mesh::PolyhedralMesh::
polyhedralFamilySerializerMng()
{
  return m_polyhedral_family_serializer_mng.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_endUpdateFamilies()
{
  for (auto& family : m_arcane_families) {
    family->endUpdate();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_computeFamilySynchronizeInfos()
{
  m_subdomain->traceMng()->info() << "Computing family synchronization information for " << name();
  for (auto& family : m_arcane_families) {
    family->computeSynchronizeInfos();
  }
 
  // Écrire la topologie pour la synchronisation des mailles
  if (!platform::getEnvironmentVariable("ARCANE_DUMP_VARIABLE_SYNCHRONIZER_TOPOLOGY").null()) {
    auto* var_syncer = cellFamily()->allItemsSynchronizer();
    Int32 iteration = m_subdomain->commonVariables().globalIteration();
    String file_name = String::format("{0}_sync_topology_iter{1}.json", name(), iteration);
    mesh_utils::dumpSynchronizerTopologyJSON(var_syncer, file_name);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_notifyEndUpdateForFamilies()
{
  for (auto& family : m_arcane_families)
    family->_internalApi()->notifyEndUpdateFromMesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
_computeGroupSynchronizeInfos()
{
  auto action = [](ItemGroup& group) {
    if (group.hasSynchronizer())
      group.synchronizer()->compute();
  };
 
  m_trace_mng->info() << "Computing group synchronization information for " << name();
  meshvisitor::visitGroups(this, action);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String Arcane::mesh::PolyhedralMesh::
name() const
{
  return m_name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
dimension()
{
  return m_mesh->dimension();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
nbNode()
{
  return m_mesh->nbNode();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
nbEdge()
{
  return m_mesh->nbEdge();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
nbFace()
{
  return m_mesh->nbFace();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
nbCell()
{
  return m_mesh->nbCell();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer Arcane::mesh::PolyhedralMesh::
nbItem(eItemKind ik)
{
  return m_mesh->nbItem(ik);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
NodeGroup mesh::PolyhedralMesh::
allNodes()
{
  if (m_default_arcane_families[IK_Node])
    return m_default_arcane_families[IK_Node]->allItems();
  else
    return NodeGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
EdgeGroup mesh::PolyhedralMesh::
allEdges()
{
  if (m_default_arcane_families[IK_Edge])
    return m_default_arcane_families[IK_Edge]->allItems();
  else
    return EdgeGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
allFaces()
{
  if (m_default_arcane_families[IK_Face])
    return m_default_arcane_families[IK_Face]->allItems();
  else
    return FaceGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::
allCells()
{
  if (m_default_arcane_families[IK_Cell])
    return m_default_arcane_families[IK_Cell]->allItems();
  else
    return CellGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
NodeGroup mesh::PolyhedralMesh::
ownNodes()
{
  if (m_default_arcane_families[IK_Node])
    return m_default_arcane_families[IK_Node]->allItems().own();
  else
    return NodeGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
EdgeGroup mesh::PolyhedralMesh::
ownEdges()
{
  if (m_default_arcane_families[IK_Edge])
    return m_default_arcane_families[IK_Edge]->allItems().own();
  else
    return EdgeGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
ownFaces()
{
  if (m_default_arcane_families[IK_Face])
    return m_default_arcane_families[IK_Face]->allItems().own();
  else
    return FaceGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::
ownCells()
{
  if (m_default_arcane_families[IK_Cell])
    return m_default_arcane_families[IK_Cell]->allItems().own();
  else
    return CellGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
outerFaces()
{
  if (m_default_arcane_families[IK_Cell])
    return m_default_arcane_families[IK_Cell]->allItems().outerFaceGroup();
  else
    return FaceGroup{};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralFamily* mesh::PolyhedralMesh::
_createItemFamily(eItemKind ik, const String& name)
{
  m_mesh->addFamily(ik, name);
  m_arcane_families.push_back(std::make_unique<PolyhedralFamily>(this, ik, name));
  auto current_family = m_arcane_families.back().get();
  if (m_default_arcane_families[ik] == nullptr) {
    m_default_arcane_families[ik] = current_family;
    _updateMeshInternalList(ik);
  }
  m_item_family_collection.add(current_family);
  current_family->build();
  return current_family;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
createItemFamily(eItemKind ik, const String& name)
{
  return _createItemFamily(ik, name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
_createUnitMesh()
{
  createItemFamily(IK_Cell, "CellFamily");
  createItemFamily(IK_Node, "NodeFamily");
  auto cell_family = m_default_arcane_families[IK_Cell];
  auto node_family = m_default_arcane_families[IK_Node];
  Int64UniqueArray cell_uids{ 0 }, node_uids{ 0, 1, 2, 3, 4, 5 };
  // à faire : ajouter une structure cell_lids (contenant l'avenir)
  PolyhedralTools::ItemLocalIds cell_lids, node_lids;
  m_mesh->scheduleAddItems(cell_family, cell_uids.constView(), cell_lids);
  m_mesh->scheduleAddItems(node_family, node_uids.constView(), node_lids);
  int nb_node = 6;
  Int64UniqueArray node_cells_uids{ 0, 0, 0, 0, 0, 0 };
  m_mesh->scheduleAddConnectivity(cell_family, cell_lids, nb_node, node_family, node_uids, String{ "CellToNodes" });
  m_mesh->scheduleAddConnectivity(node_family, node_lids, 1, cell_family,
                                  node_cells_uids, String{ "NodeToCells" });
  m_mesh->applyScheduledOperations();
  cell_family->endUpdate();
  node_family->endUpdate();
  endUpdate();
  // Simuler ce que ferait IMeshModifier::endUpdate => les familles par défaut sont complétées.
  // Les familles créées après un premier appel à endUpdate ne sont pas des familles par défaut
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
endUpdate()
{
  // crée des familles par défaut vides qui n'ont pas encore été créées
  for (auto ik = 0; ik < NB_ITEM_KIND; ++ik) {
    if (m_default_arcane_families[ik] == nullptr && ik != eItemKind::IK_DoF) {
      String name = String::concat(itemKindName((eItemKind)ik), "EmptyFamily");
      m_empty_arcane_families[ik] = std::make_unique<mesh::PolyhedralFamily>(this, (eItemKind)ik, name);
      m_default_arcane_families[ik] = m_empty_arcane_families[ik].get();
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
nodeFamily()
{
  return m_default_arcane_families[IK_Node];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
edgeFamily()
{
  return m_default_arcane_families[IK_Edge];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
faceFamily()
{
  return m_default_arcane_families[IK_Face];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
cellFamily()
{
  return m_default_arcane_families[IK_Cell];
}
 
void mesh::PolyhedralMesh::
_updateMeshInternalList(eItemKind kind)
{
  switch (kind) {
  case IK_Cell:
    m_mesh_item_internal_list.cells = m_default_arcane_families[kind]->itemsInternal();
    m_mesh_item_internal_list._internalSetCellSharedInfo(m_default_arcane_families[kind]->commonItemSharedInfo());
    break;
  case IK_Face:
    m_mesh_item_internal_list.faces = m_default_arcane_families[kind]->itemsInternal();
    m_mesh_item_internal_list._internalSetFaceSharedInfo(m_default_arcane_families[kind]->commonItemSharedInfo());
    break;
  case IK_Edge:
    m_mesh_item_internal_list.edges = m_default_arcane_families[kind]->itemsInternal();
    m_mesh_item_internal_list._internalSetEdgeSharedInfo(m_default_arcane_families[kind]->commonItemSharedInfo());
    break;
  case IK_Node:
    m_mesh_item_internal_list.nodes = m_default_arcane_families[kind]->itemsInternal();
    m_mesh_item_internal_list._internalSetNodeSharedInfo(m_default_arcane_families[kind]->commonItemSharedInfo());
    break;
  case IK_DoF:
  case IK_Particle:
  case IK_Unknown:
    break;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralFamily* mesh::PolyhedralMesh::
_itemFamily(eItemKind ik)
{
  return m_default_arcane_families[ik];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
itemFamily(eItemKind ik)
{
  return _itemFamily(ik);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemTypeMng* mesh::PolyhedralMesh::
itemTypeMng() const
{
  return m_item_type_mng;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralFamily* mesh::PolyhedralMesh::
_findItemFamily(eItemKind ik, const String& name, bool create_if_needed)
{
  // Vérifie s'il s'agit d'une famille par défaut
  auto found_family = _itemFamily(ik);
  if (found_family) {
    if (found_family->name() == name)
      return found_family;
  }
  for (auto& family : m_arcane_families) {
    if (family->itemKind() == ik && family->name() == name)
      return family.get();
  }
  if (!create_if_needed)
    return nullptr;
  return _createItemFamily(ik, name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* mesh::PolyhedralMesh::
findItemFamily(eItemKind ik, const String& name, bool create_if_needed, bool register_modifier_if_created)
{
  ARCANE_UNUSED(register_modifier_if_created); // IItemFamilyModifier n'est pas encore utilisé dans le maillage polyédrique
  return _findItemFamily(ik, name, create_if_needed);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralFamily* mesh::PolyhedralMesh::
arcaneDefaultFamily(eItemKind ik)
{
  return m_default_arcane_families[ik];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
VariableNodeReal3& mesh::PolyhedralMesh::
nodesCoordinates()
{
  ARCANE_ASSERT(m_arcane_node_coords, ("Node coordinates not yet loaded."));
  return *m_arcane_node_coords;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemGroup mesh::PolyhedralMesh::
findGroup(const String& name)
{
  ItemGroup group;
  for (auto& family : m_arcane_families) {
    group = family->findGroup(name);
    if (!group.null())
      return group;
  }
  return group;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemGroupCollection mesh::PolyhedralMesh::
groups()
{
  m_all_groups.clear();
  for (auto& family : m_arcane_families) {
    for (ItemGroupCollection::Enumerator i_group(family->groups()); ++i_group;)
      m_all_groups.add(*i_group);
  }
  return m_all_groups;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
destroyGroups()
{
  for (auto& family : m_arcane_families) {
    family->destroyGroups();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamilyCollection mesh::PolyhedralMesh::
itemFamilies()
{
  return m_item_family_collection;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshInternal* mesh::PolyhedralMesh::
_internalApi()
{
  return m_internal_api.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshCompactMng* mesh::PolyhedralMesh::
_compactMng()
{
  return m_compact_mng.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
addItems(Int64ConstArrayView unique_ids, Int32ArrayView local_ids, eItemKind ik, const String& family_name)
{
  ARCANE_ASSERT((unique_ids.size() == local_ids.size()), ("local and unique ids arrays must have same size"))
  auto* item_family = _findItemFamily(ik, family_name, false);
  PolyhedralTools::ItemLocalIds item_local_ids;
  m_mesh->scheduleAddItems(item_family, unique_ids, item_local_ids);
  auto mesh_state = m_mesh->applyScheduledOperations();
  item_local_ids.fillArrayView(local_ids, mesh_state);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
addItems(Int64ConstArrayView unique_ids, Int32ArrayView local_ids, Int32ConstArrayView owners, eItemKind ik, const String& family_name)
{
  ARCANE_ASSERT((unique_ids.size() == local_ids.size() && (unique_ids.size() == owners.size())), ("local/unique ids and owners arrays must have same size"))
  auto* item_family = _findItemFamily(ik, family_name, false);
  PolyhedralTools::ItemLocalIds item_local_ids;
  m_mesh->scheduleAddItems(item_family, unique_ids, owners, item_local_ids);
  auto mesh_state = m_mesh->applyScheduledOperations();
  item_local_ids.fillArrayView(local_ids, mesh_state);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
removeItems(Int32ConstArrayView local_ids, eItemKind ik, const String& family_name)
{
  auto* item_family = _findItemFamily(ik, family_name, false);
  if (!item_family) {
    ARCANE_FATAL("ItemFamily with name {0} and kind {1} does not exist in the mesh.", family_name, ik);
  }
  m_mesh->scheduleRemoveItems(item_family, local_ids);
  m_mesh->applyScheduledOperations();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
removeItems(Int32ConstArrayView local_ids, IItemFamily* family)
{
  if (local_ids.empty())
    return;
  if (!family) {
    ARCANE_FATAL("Invalid IItemFamily passed to removeItems.");
  }
  removeItems(local_ids, family->itemKind(), family->name());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
addNodes(Int64ConstArrayView nodes_uid, Int32ArrayView nodes_lid)
{
  addItems(nodes_uid, nodes_lid, IK_Node, nodeFamily()->name());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
exchangeItems()
{
  m_trace_mng->info() << "PolyhedralMesh::_exchangeItems() do_compact?=" << "false"
                      << " nb_exchange=" << 0 << " version=" << 0;
  _exchangeItems();
  String check_exchange = platform::getEnvironmentVariable("ARCANE_CHECK_EXCHANGE");
  if (!check_exchange.null()) {
    m_mesh_checker.checkGhostCells();
    m_trace_mng->pwarning() << "CHECKING SYNCHRONISATION !";
    m_mesh_checker.checkVariablesSynchronization();
    m_mesh_checker.checkItemGroupsSynchronization();
  }
  if (checkLevel() >= 2)
    m_mesh_checker.checkValidMesh();
  else if (checkLevel() >= 1)
    m_mesh_checker.checkValidConnectivity();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
_exchangeItems()
{
  // à faire : gérer les sous-maillages, cf. DynamicMesh
 
  Trace::Setter mci(traceMng(), _className());
 
  if (!m_is_dynamic)
    ARCANE_FATAL("property isDynamic() has to be 'true'");
 
  if (arcane_debug_load_balancing) {
    for (auto& family : m_arcane_families) {
      family->itemsNewOwner().checkIfSync();
    }
  }
 
  IMeshExchanger* iexchanger = m_mesh_exchange_mng->beginExchange();
 
  // Si aucune entité à échanger, retourner
  if (iexchanger->computeExchangeInfos()) {
    m_trace_mng->pwarning() << "No load balance is performed";
    m_mesh_exchange_mng->endExchange();
    return;
  }
 
  // Effectue les informations d'échange
  iexchanger->processExchange();
 
  // Supprime les éléments qui ne sont plus dans le sous-domaine actuel
  iexchanger->removeNeededItems();
 
  // Mets à jour les groupes : supprimer les entités disparues
  // invalider les groupes calculés
  {
    auto action = [](ItemGroup& group) {
      if (group.internal()->hasComputeFunctor() || group.isLocalToSubDomain())
        group.invalidate();
      else
        group.internal()->removeSuppressedItems();
    };
    meshvisitor::visitGroups(this, action);
  }
 
  iexchanger->allocateReceivedItems();
 
  // Équivalent de DynamicMesh::_internalEndUpdateInit
  _endUpdateFamilies();
  _computeFamilySynchronizeInfos();
 
  // Mets à jour les groupes
  iexchanger->updateItemGroups();
 
  _computeGroupSynchronizeInfos();
 
  iexchanger->updateVariables();
 
  // Équivalent DynamicMesh::_internalEndUpdateFinal(bool)
  // vérifie que le maillage est conforme à la référence (connectivité séquentielle complète dans un fichier)
  m_mesh_checker.checkMeshFromReferenceFile();
  _notifyEndUpdateForFamilies();
 
  iexchanger->finalizeExchange();
 
  m_mesh_exchange_mng->endExchange();
 
  // // à faire : gérer les fantômes supplémentaires
  // if (m_extra_ghost_cells_builder->hasBuilder() || m_extra_ghost_particles_builder->hasBuilder())
  //   this->endUpdate(true,false);
  // else
  this->endUpdate();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void mesh::PolyhedralMesh::
prepareForDump()
{
  // ne rien faire pour l'instant
  auto want_dump = false;
  auto need_compact = false;
  m_trace_mng->info(4) << "DynamicMesh::prepareForDump() name=" << name()
                       << " need_compact?=" << need_compact
                       << " want_dump?=" << want_dump
                       << " timestamp=" << 0;
 
  {
    eMeshEventType t = eMeshEventType::BeginPrepareDump;
    m_mesh_events.eventObservable(t).notify(MeshEventArgs(this, t));
  }
 
  // à faire : utiliser les propriétés
  if (want_dump) {
    for (auto& family : m_arcane_families) {
      family->prepareForDump();
    }
  }
 
  {
    eMeshEventType t = eMeshEventType::EndPrepareDump;
    m_mesh_events.eventObservable(t).notify(MeshEventArgs(this, t));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::
allActiveCells()
{
  return allCells().activeCellGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::ownActiveCells()
{
  return allCells().ownActiveCellGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::
allLevelCells(const Integer& level)
{
  return allCells().levelCellGroup(level);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CellGroup mesh::PolyhedralMesh::
ownLevelCells(const Integer& level)
{
  return allCells().ownLevelCellGroup(level);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
allActiveFaces()
{
  return allCells().activeFaceGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
ownActiveFaces()
{
  return allCells().ownActiveFaceGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
innerActiveFaces()
{
  return allCells().innerActiveFaceGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup mesh::PolyhedralMesh::
outerActiveFaces()
{
  return allCells().outerActiveFaceGroup();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshUtilities* mesh::PolyhedralMesh::
utilities()
{
  return m_mesh_utilities.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
VariableItemInt32& mesh::PolyhedralMesh::
itemsNewOwner(eItemKind ik)
{
  IItemFamily* item_family = _itemFamily(ik);
  ARCANE_CHECK_POINTER(item_family);
  return item_family->itemsNewOwner();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer mesh::PolyhedralMesh::
checkLevel() const
{
  return m_mesh_checker.checkLevel();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamilyNetwork* mesh::PolyhedralMesh::
itemFamilyNetwork()
{
  return m_item_family_network.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IGhostLayerMng* mesh::PolyhedralMesh::
ghostLayerMng() const
{
  return m_ghost_layer_mng.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshModifierInternal* mesh::PolyhedralMesh::
_modifierInternalApi()
{
  return m_internal_api.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
mesh::PolyhedralMeshImpl* mesh::PolyhedralMesh::_impl()
{
  return m_mesh.get();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#else // ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
class PolyhedralMeshImpl
{};
} // namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Arcane::mesh::PolyhedralMesh::
~PolyhedralMesh() = default;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Arcane::mesh::PolyhedralMesh::
PolyhedralMesh(ISubDomain* subdomain, const MeshBuildInfo& mbi)
: EmptyMesh{ subdomain->traceMng() }
, m_subdomain{ subdomain }
, m_mesh{ nullptr }
, m_mesh_kind(mbi.meshKind())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
read([[maybe_unused]] const String& filename)
{
  _errorEmptyMesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Arcane::mesh::PolyhedralMesh::
allocateItems(const Arcane::ItemAllocationInfo& item_allocation_info)
{
  ARCANE_UNUSED(item_allocation_info);
  _errorEmptyMesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif // ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
class ARCANE_MESH_EXPORT PolyhedralMeshFactory
: public AbstractService
, public IMeshFactory
{
 public:
 
  explicit PolyhedralMeshFactory(const ServiceBuildInfo& sbi)
  : AbstractService(sbi)
  {}
 
 public:
 
  void build() override {}
  IPrimaryMesh* createMesh(IMeshMng* mm, const MeshBuildInfo& build_info) override
  {
    ISubDomain* sd = mm->variableMng()->_internalApi()->internalSubDomain();
    return new mesh::PolyhedralMesh(sd, build_info);
  }
 
  static String name() { return "ArcanePolyhedralMeshFactory"; }
};
 
ARCANE_REGISTER_SERVICE(PolyhedralMeshFactory,
                        ServiceProperty(PolyhedralMeshFactory::name().localstr(), ST_Application),
                        ARCANE_SERVICE_INTERFACE(IMeshFactory));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#if ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String mesh::PolyhedralMesh::
factoryName() const
{
  return PolyhedralMeshFactory::name();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif // ARCANE_HAS_POLYHEDRAL_MESH_TOOLS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/