Lima.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Lima.cc                                                     (C) 2000-2026 */
/*                                                                           */
/* Reading/Writing a file in Lima format.                                    */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Iostream.h"
#include "arcane/utils/StdHeader.h"
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/ArcanePrecomp.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/Collection.h"
#include "arcane/utils/Enumerator.h"
#include "arcane/utils/PlatformUtils.h"
#include "arcane/utils/Real3.h"
#include "arcane/utils/OStringStream.h"
#include "arcane/utils/CheckedConvert.h"
#include "arcane/utils/StringBuilder.h"
 
#include "arcane/core/IMeshReader.h"
#include "arcane/core/IGhostLayerMng.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/IIOMng.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IPrimaryMesh.h"
#include "arcane/core/Item.h"
#include "arcane/core/ItemTypeMng.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/ArcaneException.h"
#include "arcane/core/Service.h"
#include "arcane/core/Timer.h"
#include "arcane/core/ServiceFactory.h"
#include "arcane/core/ServiceInfo.h"
#include "arcane/core/CaseOptionsMain.h"
#include "arcane/core/MeshUtils.h"
#include "arcane/core/ItemEnumerator.h"
#include "arcane/core/VariableTypes.h"
#include "arcane/core/ServiceBuildInfo.h"
#include "arcane/core/XmlNodeList.h"
#include "arcane/core/IXmlDocumentHolder.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/FactoryService.h"
#include "arcane/core/IMeshWriter.h"
#include "arcane/core/AbstractService.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/ICaseMeshReader.h"
#include "arcane/core/IMeshBuilder.h"
 
#include "arcane/lima/LimaCutInfosReader.h"
#include "arcane/lima/internal/LimaUtils.h"
 
#include <Lima/lima++.h>
 
#include <memory>
#include <algorithm>
#include <mutex>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
 
  // Mutex to protect calls to Lima in case MLI2 is used
  // because this format uses HDF5 which is not thread-safe in most cases
  // (this depends on the HDF5 compilation options but the thread-safe
  // version is incompatible with the MPI version and generally we need this
  // latter)
  std::mutex global_lima_mutex;
  class GlobalLimaMutex
  {
   public:
 
    explicit GlobalLimaMutex(bool is_active)
    : m_is_active(is_active)
    {
      if (m_is_active)
        global_lima_mutex.lock();
    }
    ~GlobalLimaMutex()
    {
      if (m_is_active)
        global_lima_mutex.unlock();
    }
 
   private:
 
    bool m_is_active = false;
  };
 
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class LimaMeshBase
: public TraceAccessor
{
 public:
 
  LimaMeshBase(ISubDomain* sub_domain)
  : TraceAccessor(sub_domain->traceMng())
  , m_sub_domain(sub_domain)
  {}
  virtual ~LimaMeshBase() {}
 
 public:
 
  virtual bool readMesh(Lima::Maillage& lima, IPrimaryMesh* mesh, const String& filename,
                        const String& dir_name, bool use_internal_partition, Real length_multiplier) = 0;
 
  ISubDomain* subDomain() const { return m_sub_domain; }
 
 protected:
 private:
 
  ISubDomain* m_sub_domain;
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename ReaderWrapper>
class LimaWrapper
: public LimaMeshBase
{
 public:
 
  LimaWrapper(ISubDomain* sub_domain)
  : LimaMeshBase(sub_domain)
  , m_cut_infos_reader(new LimaCutInfosReader(sub_domain->parallelMng()))
  {}
 
  ~LimaWrapper()
  {
    delete m_cut_infos_reader;
  }
 
 public:
 
  virtual bool readMesh(Lima::Maillage& lima, IPrimaryMesh* mesh, const String& filename,
                        const String& dir_name, bool use_internal_partition, Real length_multiplier);
 
 private:
 
  LimaCutInfosReader* m_cut_infos_reader;
  ReaderWrapper m_wrapper;
 
  bool _readMesh(Lima::Maillage& lima, IPrimaryMesh* mesh, const String& filename,
                 const String& dir_name, bool use_internal_partition, Real length_multiplier);
 
  void _getProcList(UniqueArray<Integer>& proc_list, const String& dir_name);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class LimaMeshReaderWrapper
{
 public:
 
  void setLima(const Lima::Maillage& lima_mesh)
  {
    m_lima_mesh = lima_mesh;
  }
 
 protected:
 
  Lima::Maillage m_lima_mesh;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Lima2DReaderWrapper
: public LimaMeshReaderWrapper
{
 public:
 
  typedef Lima::Surface LimaCellGroup;
  typedef Lima::Polygone LimaCell;
  typedef Lima::Ligne LimaFaceGroup;
  typedef Lima::Bras LimaFace;
 
 public:
 
  Integer nbCellGroup()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_surfaces());
  }
  Integer nbFaceGroup()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_lignes());
  }
  LimaCellGroup cellGroup(Integer i)
  {
    return m_lima_mesh.surface(i);
  }
  LimaFaceGroup faceGroup(Integer i)
  {
    return m_lima_mesh.ligne(i);
  }
  Integer faceGroupNbFace(const LimaFaceGroup& group)
  {
    return CheckedConvert::toInteger(group.nb_bras());
  }
  LimaFace faceFaceGroup(const LimaFaceGroup& group, Integer i)
  {
    return group.bras(i);
  }
  Integer cellGroupNbCell(const LimaCellGroup& group)
  {
    return CheckedConvert::toInteger(group.nb_polygones());
  }
  LimaCell cellCellGroup(const LimaCellGroup& group, Integer i)
  {
    return group.polygone(i);
  }
  LimaCell cell(Integer i)
  {
    return m_lima_mesh.polygone(i);
  }
  LimaFace face(Integer i)
  {
    return m_lima_mesh.bras(i);
  }
  Integer nbCell()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_polygones());
  }
  Integer nbFace()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_bras());
  }
  int limaDimension()
  {
    return Lima::D2;
  }
  const char* strDimension()
  {
    return "2D";
  }
  static Integer cellToType(Integer nb_node)
  {
    switch (nb_node) {
    case 3:
      return IT_Triangle3;
    case 4:
      return IT_Quad4;
    case 5:
      return IT_Pentagon5;
    case 6:
      return IT_Hexagon6;
    default:
      break;
    }
    return IT_NullType;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Lima3DReaderWrapper
: public LimaMeshReaderWrapper
{
 public:
 
  typedef Lima::Volume LimaCellGroup;
  typedef Lima::Polyedre LimaCell;
  typedef Lima::Surface LimaFaceGroup;
  typedef Lima::Polygone LimaFace;
 
  Integer nbCellGroup()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_volumes());
  }
  Integer nbFaceGroup()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_surfaces());
  }
  LimaCellGroup cellGroup(Integer i)
  {
    return m_lima_mesh.volume(i);
  }
  LimaFaceGroup faceGroup(Integer i)
  {
    return m_lima_mesh.surface(i);
  }
  Integer faceGroupNbFace(const LimaFaceGroup& group)
  {
    return CheckedConvert::toInteger(group.nb_polygones());
  }
  LimaFace faceFaceGroup(const LimaFaceGroup& group, Integer i)
  {
    return group.polygone(i);
  }
  Integer cellGroupNbCell(const LimaCellGroup& group)
  {
    return CheckedConvert::toInteger(group.nb_polyedres());
  }
  LimaCell cellCellGroup(const LimaCellGroup& group, Integer i)
  {
    return group.polyedre(i);
  }
  LimaCell cell(Integer i)
  {
    return m_lima_mesh.polyedre(i);
  }
  LimaFace face(Integer i)
  {
    return m_lima_mesh.polygone(i);
  }
  Integer nbCell()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_polyedres());
  }
  Integer nbFace()
  {
    return CheckedConvert::toInteger(m_lima_mesh.nb_polygones());
  }
  int limaDimension()
  {
    return Lima::D3;
  }
  const char* strDimension()
  {
    return "3D";
  }
  static Integer cellToType(Integer nb_node)
  {
    switch (nb_node) {
    case 4:
      return IT_Tetraedron4;
    case 5:
      return IT_Pyramid5;
    case 6:
      return IT_Pentaedron6;
    case 8:
      return IT_Hexaedron8;
    case 10:
      return IT_Heptaedron10;
    case 12:
      return IT_Octaedron12;
    default:
      break;
    }
    return IT_NullType;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class LimaMeshReader
: public TraceAccessor
{
 public:
 
  LimaMeshReader(ISubDomain* sd)
  : TraceAccessor(sd->traceMng())
  , m_sub_domain(sd)
  {}
 
 public:
 
  auto readMesh(IPrimaryMesh* mesh, const String& file_name,
                const String& dir_name, bool use_internal_partition,
                bool use_length_unit) -> IMeshReader::eReturnType;
 
 private:
 
  ISubDomain* m_sub_domain;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class LimaMeshReaderService
: public AbstractService
, public IMeshReader
{
 public:
 
  explicit LimaMeshReaderService(const ServiceBuildInfo& sbi);
 
 public:
 
  void build() {}
 
 public:
 
  bool allowExtension(const String& str) override
  {
    return str == "unf" || str == "mli" || str == "mli2" || str == "ice" || str == "uns" || str == "unv";
  }
 
  eReturnType readMeshFromFile(IPrimaryMesh* mesh, const XmlNode& mesh_node,
                               const String& file_name,
                               const String& dir_name, bool use_internal_partition) override;
  ISubDomain* subDomain() { return m_sub_domain; }
 
 private:
 
  ISubDomain* m_sub_domain;
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE(LimaMeshReaderService,
                        ServiceProperty("Lima", ST_SubDomain),
                        ARCANE_SERVICE_INTERFACE(IMeshReader));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
LimaMeshReaderService::
LimaMeshReaderService(const ServiceBuildInfo& sbi)
: AbstractService(sbi)
, m_sub_domain(sbi.subDomain())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshReader::eReturnType LimaMeshReaderService::
readMeshFromFile(IPrimaryMesh* mesh, const XmlNode& mesh_node,
                 const String& filename, const String& dir_name,
                 bool use_internal_partition)
{
  ISubDomain* sd = subDomain();
 
  String case_doc_lang = "en";
  ICaseDocument* case_doc = sd->caseDocument();
  if (case_doc)
    case_doc_lang = case_doc->language();
 
  // Checks if we want to use the length unit in the mesh file.
  String use_unit_attr_name = "utilise-unite";
  String use_unit_str = mesh_node.attrValue(use_unit_attr_name);
  if (case_doc_lang == "en") {
    // For compatibility reasons, check if 'utilise-unite' is present
    // if so, use it. Otherwise, use the English term.
    if (!use_unit_str.empty()) {
      warning() << "'utilise-unite' should only be used for French datasets."
                << "Use 'use-unit' instead";
    }
    use_unit_attr_name = "use-unit";
  }
  else {
    // If it is not English and 'utilise-unite' is not found,
    // try using 'use-unit'. This is necessary to take into account
    // MeshReaderMng::isUseMeshUnit().
    if (use_unit_str.null()) {
      info() << "Attribute '" << use_unit_attr_name << "' is not found. Trying with 'use-unit'";
      use_unit_attr_name = "use-unit";
    }
  }
 
  // Since Arcane 2.8.0, we default to reading length units if
  // the environment variable ARCANE_LIMA_DEFAULT_NO_UNIT is defined.
  bool use_length_unit = true;
  if (!platform::getEnvironmentVariable("ARCANE_LIMA_DEFAULT_NO_UNIT").null())
    use_length_unit = false;
  info() << "Default value for unit usage: " << use_length_unit;
 
  if (use_unit_str.empty())
    use_unit_str = mesh_node.attrValue(use_unit_attr_name);
  info() << "Checking for attribute '" << use_unit_attr_name << "' value='" << use_unit_str << "'";
  if (!use_unit_str.empty()) {
    if (use_unit_str == "1" || use_unit_str == "true")
      use_length_unit = true;
    else if (use_unit_str == "0" || use_unit_str == "false")
      use_length_unit = false;
    else
      ARCANE_FATAL("Invalid value boolean value '{0}' for '{1}' attribute."
                   " Valid values are '0', '1' 'true' or 'false'",
                   use_unit_str, use_unit_attr_name);
  }
 
  info() << "Uses Lima's length unit: " << use_length_unit << " (lang=" << case_doc_lang << ")";
 
  LimaMeshReader reader(sd);
  return reader.readMesh(mesh, filename, dir_name, use_internal_partition, use_length_unit);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshReader::eReturnType LimaMeshReader::
readMesh(IPrimaryMesh* mesh, const String& filename, const String& dir_name,
         bool use_internal_partition, bool use_length_unit)
{
  if (filename.null() || filename.empty())
    return IMeshReader::RTIrrelevant;
 
  ISubDomain* sd = m_sub_domain;
  ITimerMng* timer_mng = sd->timerMng();
  LimaMeshBase* lm = 0;
  ICaseDocument* case_doc = sd->caseDocument();
 
  info() << "Lima: use_length_unit=" << use_length_unit
         << " use_internal_partition=" << use_internal_partition;
  Real length_multiplier = 0.0;
  if (use_length_unit) {
    String code_system;
    if (case_doc)
      code_system = case_doc->codeUnitSystem();
    if (code_system.null() || code_system.empty()) {
      info() << "No unit system configured. Use MKS unit system.";
      length_multiplier = 1.0;
    }
    else if (code_system == "CGS") {
      length_multiplier = 100.0;
    }
    else if (code_system == "MKS") {
      length_multiplier = 1.0;
    }
    else {
      ARCANE_FATAL("Unknown unit system '{0}' (valid values are: 'CGS' or 'MKS'", code_system);
    }
  }
 
  std::string loc_file_name = filename.localstr();
  size_t rpos = loc_file_name.rfind(".mli");
  size_t rpos2 = loc_file_name.rfind(".mli2");
  const bool need_mutex = rpos2 != std::string::npos;
  info() << " FILE_NAME=" << loc_file_name;
  info() << " RPOS MLI=" << rpos << " s=" << loc_file_name.length();
  info() << " RPOS MLI2=" << rpos2 << " s=" << loc_file_name.length();
 
  // If each PE reads the mesh and we use shared memory,
  // the reading of Lima files will happen concurrently.
  // Since Lima's 'Malipp' API does not support multi-threading,
  // we switch to the classic API in this case.
  // Even with the classic API, there are crashes with certain
  // versions of Lima (at least 7.11.2) when using the MLI2
  // format (because it uses HDF5). To avoid any problems, we put a lock
  // around the read/write in this case.
  bool has_thread = !use_internal_partition && mesh->parallelMng()->isThreadImplementation();
  // We cannot use the mali pp API with threads
  if (!has_thread && use_internal_partition && ((rpos + 4) == loc_file_name.length())) {
    info() << "Use direct partitioning with mli";
#ifdef ARCANE_LIMA_HAS_MLI
    return LimaUtils::_directLimaPartitionMalipp(timer_mng, mesh, filename, length_multiplier);
#else
    ARCANE_FATAL("Can not use 'mli' files because Lima is not compiled with 'mli' support");
#endif
  }
  else if (!has_thread && use_internal_partition && ((rpos2 + 5) == loc_file_name.length())) {
    info() << "Use direct partitioning with mli2";
#ifdef ARCANE_LIMA_HAS_MLI2
    return LimaUtils::_directLimaPartitionMalipp2(timer_mng, mesh, filename, length_multiplier);
#else
    ARCANE_FATAL("Can not use 'mli2' files because Lima is not compiled with 'mli2' support");
#endif
  }
  else {
    info() << "Loading Lima file '" << filename << "'";
 
    const char* version = Lima::lima_version();
    info() << "Using version " << version << " of Lima";
 
    Timer time_to_read(sd, "ReadLima", Timer::TimerReal);
 
    // No specific preparation needed
    LM_TYPEMASQUE preparation = LM_ORIENTATION | LM_COMPACTE;
 
    log() << "Starting file read " << filename;
 
    Lima::Maillage lima(filename.localstr());
 
    try {
      {
        Timer::Sentry sentry(&time_to_read);
        Timer::Phase t_action(sd, TP_InputOutput);
        GlobalLimaMutex sc(need_mutex);
        lima.lire(filename.localstr(), Lima::SUFFIXE, true);
        //warning() << "Lima preparation removed";
        lima.preparation_parametrable(preparation);
      }
    }
    catch (const Lima::erreur& ex) {
      ARCANE_FATAL("Can not read lima file '{0}' error is '{1}'", filename, ex.what());
    }
    catch (...) {
      ARCANE_FATAL("Can not read lima file '{0}'", filename);
    }
 
    info() << "Mesh read and preparation time (unit: seconds): "
           << time_to_read.lastActivationTime();
    // If the dimension has not yet been set, use the one
    // provided by Lima.
    if (mesh->dimension() <= 0) {
      if (lima.dimension() == Lima::D3) {
        mesh->setDimension(3);
        info() << "3D Mesh";
      }
      else if (lima.dimension() == Lima::D2) {
        mesh->setDimension(2);
        info() << "2D Mesh";
      }
    }
 
    if (mesh->dimension() == 3) {
      lm = new LimaWrapper<Lima3DReaderWrapper>(sd);
    }
    else if (mesh->dimension() == 2) {
      lm = new LimaWrapper<Lima2DReaderWrapper>(sd);
    }
    if (!lm) {
      log() << "Mesh dimension not recognized by lima";
      return IMeshReader::RTIrrelevant;
    }
 
    bool ret = lm->readMesh(lima, mesh, filename, dir_name, use_internal_partition, length_multiplier);
    if (ret)
      return IMeshReader::RTError;
 
    // To be done if there are multiple ghost cell layers
    {
      Integer nb_ghost_layer = mesh->ghostLayerMng()->nbGhostLayer();
      if (nb_ghost_layer > 1)
        mesh->synchronizeGroupsAndVariables();
    }
 
    delete lm;
  }
 
  return IMeshReader::RTOk;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename ReaderWrapper> bool LimaWrapper<ReaderWrapper>::
readMesh(Lima::Maillage& lima, IPrimaryMesh* mesh, const String& filename,
         const String& dir_name, bool use_internal_partition, Real length_multiplier)
{
  return _readMesh(lima, mesh, filename, dir_name, use_internal_partition, length_multiplier);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename ReaderWrapper> bool LimaWrapper<ReaderWrapper>::
_readMesh(Lima::Maillage& lima, IPrimaryMesh* mesh, const String& file_name,
          const String& dir_name, bool use_internal_partition, Real length_multiplier)
{
  ARCANE_UNUSED(file_name);
 
  // We must use the mesh's parallelMng, which may be different
  // from that of the sub-domain, for example if the mesh is sequential.
  IParallelMng* pm = mesh->parallelMng();
 
  bool is_parallel = pm->isParallel();
  Integer sid = pm->commRank();
 
  Integer mesh_nb_node = 0;
  Integer nb_edge = 0;
  Integer lima_nb_face = 0;
  Integer mesh_nb_cell = 0;
 
  m_wrapper.setLima(lima);
 
  mesh_nb_node = CheckedConvert::toInteger(lima.nb_noeuds());
  mesh_nb_cell = m_wrapper.nbCell(); //lima.nb_polyedres();
  lima_nb_face = m_wrapper.nbFace(); //lima.nb_polygones();
  nb_edge = 0; //lima.nb_bras();
 
  info() << "-- Mesh Information (Internal):";
  info() << "Number of nodes  " << mesh_nb_node;
  info() << "Number of edges   " << nb_edge;
  info() << "Number of faces   " << lima_nb_face;
  info() << "Number of cells " << mesh_nb_cell;
  info() << "-- Mesh Information (Lima):";
  info() << "Number of nodes    " << lima.nb_noeuds();
  info() << "Number of edges     " << lima.nb_bras();
  info() << "Number of polygons " << lima.nb_polygones();
  info() << "Number of polyhedra " << lima.nb_polyedres();
  info() << "Number of surfaces  " << lima.nb_surfaces();
  info() << "Number of volumes   " << lima.nb_volumes();
 
  info() << "File length unit: " << lima.unite_longueur();
  // If 0.0, it indicates that we do not want to use the file unit.
  // In this case, this corresponds to a multiplier of 1.0
  if (length_multiplier == 0.0)
    length_multiplier = 1.0;
  else
    length_multiplier *= lima.unite_longueur();
 
  if (mesh_nb_node == 0) {
    ARCANE_FATAL("No node in mesh");
  }
 
  // ------------------------------------------------------------
  //    -------------------------------- Cell creation
  // ------------------------------------------------------------
 
  // Reads the unique IDs of the entities (in parallel)
  UniqueArray<Int64> nodes_unique_id(mesh_nb_node);
  UniqueArray<Int64> cells_unique_id(mesh_nb_cell);
  if (is_parallel && !use_internal_partition && pm->commSize() > 1) {
    m_cut_infos_reader->readItemsUniqueId(nodes_unique_id, cells_unique_id, dir_name);
  }
  else {
    for (Integer i = 0; i < mesh_nb_node; ++i)
      nodes_unique_id[i] = i;
    for (Integer i = 0; i < mesh_nb_cell; ++i)
      cells_unique_id[i] = i;
  }
 
  // For now, leave it as false.
  // If true, the UIDs are incremented to start at one.
  bool first_uid_is_one = false;
  if (!platform::getEnvironmentVariable("ARCANE_LIMA_UNIQUE_ID").null()) {
    first_uid_is_one = true;
    info() << "WARNING: UniqueId begin at 1";
  }
  if (first_uid_is_one) {
    for (Integer i = 0; i < mesh_nb_node; ++i)
      ++nodes_unique_id[i];
    for (Integer i = 0; i < mesh_nb_cell; ++i)
      ++cells_unique_id[i];
  }
 
  HashTableMapT<Int64, Real3> nodes_coords(mesh_nb_node, true);
  if (!math::isEqual(length_multiplier, 1.0)) {
    info() << "Using length multiplier v=" << length_multiplier;
    for (Integer i = 0; i < mesh_nb_node; ++i) {
      const Lima::Noeud& node = lima.noeud(i);
      Real3 coord(node.x(), node.y(), node.z());
      coord *= length_multiplier;
      nodes_coords.nocheckAdd(nodes_unique_id[i], coord);
    }
  }
  else {
    for (Integer i = 0; i < mesh_nb_node; ++i) {
      const Lima::Noeud& node = lima.noeud(i);
      Real3 coord(node.x(), node.y(), node.z());
      nodes_coords.nocheckAdd(nodes_unique_id[i], coord);
    }
  }
 
  Integer cells_infos_index = 0;
 
  UniqueArray<Integer> cells_filter;
 
  bool use_own_mesh = false;
 
  if (is_parallel && pm->commSize() > 1) {
    use_own_mesh = true;
    if (use_internal_partition)
      use_own_mesh = false;
  }
 
  typedef typename ReaderWrapper::LimaCellGroup LimaCellGroup;
  typedef typename ReaderWrapper::LimaCell LimaCell;
  typedef typename ReaderWrapper::LimaFaceGroup LimaFaceGroup;
  typedef typename ReaderWrapper::LimaFace LimaFace;
 
  if (use_own_mesh) {
    Integer nb = m_wrapper.nbCellGroup();
    for (Integer i = 0; i < nb; ++i) {
      const LimaCellGroup& lima_group = m_wrapper.cellGroup(i);
      std::string group_name = lima_group.nom();
      if (group_name == "LOCAL" || group_name == "local") {
        Integer nb_own_cell = m_wrapper.cellGroupNbCell(lima_group);
        cells_filter.resize(nb_own_cell);
        for (Integer z = 0; z < nb_own_cell; ++z) {
          cells_filter[z] = CheckedConvert::toInteger(m_wrapper.cellCellGroup(lima_group, z).id() - 1);
        }
      }
    }
  }
  else {
    if (use_internal_partition && sid != 0) {
      mesh_nb_cell = 0;
      mesh_nb_node = 0;
      lima_nb_face = 0;
    }
    cells_filter.resize(mesh_nb_cell);
    for (Integer i = 0; i < mesh_nb_cell; ++i)
      cells_filter[i] = i;
  }
 
  // Calculate the number of cells/nodes
  Integer mesh_nb_cell_node = 0;
  for (Integer j = 0, js = cells_filter.size(); j < js; ++j) {
    mesh_nb_cell_node += CheckedConvert::toInteger(m_wrapper.cell(cells_filter[j]).nb_noeuds());
  }
 
  // Array containing cell info (see IMesh::allocateMesh())
  UniqueArray<Int64> cells_infos(mesh_nb_cell_node + cells_filter.size() * 2);
 
  // Fills the array containing mesh info
  for (Integer i_cell = 0, s_cell = cells_filter.size(); i_cell < s_cell; ++i_cell) {
 
    Integer cell_indirect_id = cells_filter[i_cell];
    LimaCell lima_cell = m_wrapper.cell(cell_indirect_id);
    Integer n = CheckedConvert::toInteger(lima_cell.nb_noeuds());
 
    Integer ct = ReaderWrapper::cellToType(n);
    if (ct == IT_NullType)
      throw UnknownItemTypeException("Lima::readFile: Cell", n, cell_indirect_id);
    // Stores the cell type
    cells_infos[cells_infos_index] = ct;
    ++cells_infos_index;
    // Stores the unique ID of the cell
    cells_infos[cells_infos_index] = cells_unique_id[cell_indirect_id];
    ++cells_infos_index;
 
    // Fills the list of node numbers for the cell
    for (Integer z = 0, sz = n; z < sz; ++z) {
      Int64 node_uid = nodes_unique_id[CheckedConvert::toInteger(lima_cell.noeud(z).id() - 1)];
      cells_infos[cells_infos_index + z] = node_uid;
    }
 
#if 0
    cout << "CELL LIMA1 " << cells_unique_id[cell_indirect_id] << " ";
    for( Integer z=0; z<n; ++z )
      cout << " " << cells_infos[cells_infos_index+z];
    cout << '\n';
#endif
 
    cells_infos_index += n;
  }
 
  logdate() << "Début allocation du maillage nb_cell=" << cells_filter.size();
  mesh->allocateCells(cells_filter.size(), cells_infos, false);
  logdate() << "Fin allocation du maillage";
 
  // Positions the owners of the nodes based on Lima node groups
  if (use_internal_partition) {
    ItemInternalList nodes(mesh->itemsInternal(IK_Node));
    for (Integer i = 0, is = nodes.size(); i < is; ++i)
      nodes[i]->setOwner(sid, sid);
    ItemInternalList cells(mesh->itemsInternal(IK_Cell));
    for (Integer i = 0, is = cells.size(); i < is; ++i)
      cells[i]->setOwner(sid, sid);
  }
  else {
    Int64UniqueArray unique_ids;
    Int32UniqueArray local_ids;
    Integer sub_domain_id = subDomain()->subDomainId();
    Integer nb = CheckedConvert::toInteger(lima.nb_nuages());
    for (Integer i = 0; i < nb; ++i) {
      const Lima::Nuage& lima_group = lima.nuage(i);
      Integer nb_item_in_group = CheckedConvert::toInteger(lima_group.nb_noeuds());
      std::string group_name = lima_group.nom();
      unique_ids.resize(nb_item_in_group);
      local_ids.resize(nb_item_in_group);
      for (Integer z = 0; z < nb_item_in_group; ++z) {
        unique_ids[z] = nodes_unique_id[CheckedConvert::toInteger(lima_group.noeud(z).id() - 1)];
      }
      mesh->nodeFamily()->itemsUniqueIdToLocalId(local_ids, unique_ids, false);
      bool remove_group = false;
      if (group_name == "LOCALN" || group_name == "localn") {
        info() << "Utilisation du groupe 'LOCALN' pour indiquer que les "
               << "noeuds appartiennent au sous-domaine";
        ItemInternalList nodes(mesh->itemsInternal(IK_Node));
        for (Integer z = 0, sz = nb_item_in_group; z < sz; ++z) {
          Integer local_id = local_ids[z];
          if (local_id != NULL_ITEM_ID)
            nodes[local_id]->setOwner(sub_domain_id, sub_domain_id);
        }
        remove_group = true;
      }
      debug() << "Vérification du groupe '" << group_name << "'";
      if (group_name.length() > 3 && !remove_group) {
        String grp = group_name; //.c_str();
        if (grp.startsWith("NF_")) {
          grp = grp.substring(3);
          Int32 ghost_sub_domain_id = 0;
          bool is_bad = builtInGetValue(ghost_sub_domain_id, grp);
          debug() << "Vérification du groupe '" << group_name << "' (3) " << is_bad;
          if (!is_bad) {
            info() << "Utilisation du groupe " << group_name << " pour indiquer que le "
                   << "sous-domaine " << ghost_sub_domain_id << " est propriétaire de ses noeuds";
            ItemInternalList nodes(mesh->itemsInternal(IK_Node));
            for (Integer z = 0, sz = nb_item_in_group; z < sz; ++z) {
              Integer local_id = local_ids[z];
              if (local_id != NULL_ITEM_ID)
                nodes[local_ids[z]]->setOwner(ghost_sub_domain_id, sub_domain_id);
            }
            remove_group = true;
          }
        }
      }
    }
  }
 
  mesh->endAllocate();
 
  // Since the mesh creates its own faces without taking into account those that
  // possibly exist in Lima, we must now determine the local number
  // in our mesh for each Lima face.
  UniqueArray<Integer> faces_id(lima_nb_face); // Lima face number in the mesh \a mesh
  {
    // Number of faces/nodes
    Integer face_nb_node = 0;
    for (Integer i_face = 0; i_face < lima_nb_face; ++i_face) {
      const LimaFace& lima_face = m_wrapper.face(i_face);
      face_nb_node += CheckedConvert::toInteger(lima_face.nb_noeuds());
    }
 
    UniqueArray<Int64> faces_first_node_unique_id(lima_nb_face);
    UniqueArray<Int32> faces_first_node_local_id(lima_nb_face);
    UniqueArray<Int64> faces_nodes_unique_id(face_nb_node);
    Integer faces_nodes_unique_id_index = 0;
 
    UniqueArray<Int64> orig_nodes_id;
    orig_nodes_id.reserve(100);
 
    UniqueArray<Integer> face_nodes_index;
    face_nodes_index.reserve(100);
 
    ItemInternalList mesh_nodes(mesh->itemsInternal(IK_Node));
 
    for (Integer i_face = 0; i_face < lima_nb_face; ++i_face) {
      const LimaFace& lima_face = m_wrapper.face(i_face);
      Integer n = CheckedConvert::toInteger(lima_face.nb_noeuds());
      orig_nodes_id.resize(n);
      face_nodes_index.resize(n);
      for (Integer z = 0; z < n; ++z)
        orig_nodes_id[z] = nodes_unique_id[CheckedConvert::toInteger(lima_face.noeud(z).id() - 1)];
      //face_orig_nodes_id[z] = lima_face.noeud(z).id() - 1;
 
#if 0
      cout << "FACE LIMA1 " << lima_face.id()-1 << " ";
      for( Integer z=0; z<n; ++z )
        cout << " " << orig_nodes_id[z];
      cout << '\n';
#endif
 
      mesh_utils::reorderNodesOfFace2(orig_nodes_id, face_nodes_index);
      for (Integer z = 0; z < n; ++z)
        faces_nodes_unique_id[faces_nodes_unique_id_index + z] = orig_nodes_id[face_nodes_index[z]];
      faces_first_node_unique_id[i_face] = orig_nodes_id[face_nodes_index[0]];
      faces_nodes_unique_id_index += n;
    }
 
    mesh->nodeFamily()->itemsUniqueIdToLocalId(faces_first_node_local_id, faces_first_node_unique_id);
 
    faces_nodes_unique_id_index = 0;
    for (Integer i_face = 0; i_face < lima_nb_face; ++i_face) {
      const LimaFace& lima_face = m_wrapper.face(i_face);
      Integer n = CheckedConvert::toInteger(lima_face.nb_noeuds());
      Int64ConstArrayView face_nodes_id(n, &faces_nodes_unique_id[faces_nodes_unique_id_index]);
      Node current_node(mesh_nodes[faces_first_node_local_id[i_face]]);
      Face face = mesh_utils::getFaceFromNodesUnique(current_node, face_nodes_id);
 
      if (face.null()) {
        OStringStream ostr;
        ostr() << "(Nodes:";
        for (Integer z = 0; z < n; ++z)
          ostr() << ' ' << face_nodes_id[z];
        ostr() << " - " << current_node.localId() << ")";
        ARCANE_FATAL("INTERNAL: Lima face index={0} with nodes '{1}' is not in node/face connectivity",
                     i_face, ostr.str());
      }
      faces_id[i_face] = face.localId();
 
      faces_nodes_unique_id_index += n;
    }
  }
 
  IItemFamily* node_family = mesh->nodeFamily();
  IItemFamily* face_family = mesh->faceFamily();
  IItemFamily* cell_family = mesh->cellFamily();
 
  // Creation of groups
  if (use_internal_partition && sid != 0) {
    {
      Integer nb = CheckedConvert::toInteger(lima.nb_nuages());
      for (Integer i = 0; i < nb; ++i) {
        const Lima::Nuage& lima_group = lima.nuage(i);
        std::string group_name = lima_group.nom();
        LimaUtils::createGroup(node_family, group_name, Int32ArrayView());
      }
    }
    {
      Integer nb = m_wrapper.nbFaceGroup();
      for (Integer i = 0; i < nb; ++i) {
        const LimaFaceGroup& lima_group = m_wrapper.faceGroup(i);
        std::string group_name = lima_group.nom();
        LimaUtils::createGroup(face_family, group_name, Int32ArrayView());
      }
    }
    {
      Integer nb = m_wrapper.nbCellGroup();
      for (Integer i = 0; i < nb; ++i) {
        const LimaCellGroup& lima_group = m_wrapper.cellGroup(i);
        std::string group_name = lima_group.nom();
        LimaUtils::createGroup(cell_family, group_name, Int32ArrayView());
      }
    }
  }
  else {
    UniqueArray<Int64> unique_ids;
    UniqueArray<Int32> local_ids;
    Integer sub_domain_id = subDomain()->subDomainId();
    // Creation of node groups
    {
      Integer nb = CheckedConvert::toInteger(lima.nb_nuages());
      for (Integer i = 0; i < nb; ++i) {
        const Lima::Nuage& lima_group = lima.nuage(i);
        Integer nb_item_in_group = CheckedConvert::toInteger(lima_group.nb_noeuds());
        std::string group_name = lima_group.nom();
        unique_ids.resize(nb_item_in_group);
        local_ids.resize(nb_item_in_group);
        for (Integer z = 0; z < nb_item_in_group; ++z) {
          Integer lima_node_id = CheckedConvert::toInteger(lima_group.noeud(z).id());
          unique_ids[z] = nodes_unique_id[lima_node_id - 1];
        }
        mesh->nodeFamily()->itemsUniqueIdToLocalId(local_ids, unique_ids);
        bool remove_group = false;
        if (group_name == "LOCALN" || group_name == "localn") {
          remove_group = true;
        }
        debug() << "Vérification du groupe '" << group_name << "'";
        if (group_name.length() > 3 && !remove_group) {
          String grp = group_name.c_str();
          //grp.left(3);
          debug() << "Vérification du groupe '" << group_name << "' (2) '" << grp << "'";
          if (grp.startsWith("NF_")) {
            //grp = group_name.c_str();
            //grp.right(group_name.length()-3);
            grp = grp.substring(3);
            Integer ghost_sub_domain_id = 0;
            bool is_bad = builtInGetValue(ghost_sub_domain_id, grp);
            debug() << "Vérification du groupe '" << group_name << "' (3) " << is_bad;
            if (!is_bad) {
              remove_group = true;
            }
          }
        }
        if (!remove_group) {
          log() << "NodeGroup Name <" << group_name << "> (" << nb_item_in_group << " elements)";
          LimaUtils::createGroup(node_family, group_name, local_ids);
        }
      }
    }
    // Creation of face groups
    {
      Integer nb = m_wrapper.nbFaceGroup();
      for (Integer i = 0; i < nb; ++i) {
        const LimaFaceGroup& lima_group = m_wrapper.faceGroup(i);
        Integer nb_item_in_group = m_wrapper.faceGroupNbFace(lima_group);
        local_ids.resize(nb_item_in_group);
        // Since the face numbers provided by Lima do not correspond
        // to those created in Arcane, we use the mapping array
        for (Integer z = 0; z < nb_item_in_group; ++z) {
          local_ids[z] = faces_id[CheckedConvert::toInteger(m_wrapper.faceFaceGroup(lima_group, z).id() - 1)];
        }
        std::string group_name = lima_group.nom();
        log() << "FaceGroup Name <" << group_name << "> (" << nb_item_in_group << " elements)";
        LimaUtils::createGroup(face_family, group_name, local_ids);
      }
    }
    // Creation of cell groups
    {
      Integer nb = m_wrapper.nbCellGroup();
      for (Integer i = 0; i < nb; ++i) {
        const LimaCellGroup& lima_group = m_wrapper.cellGroup(i);
        Integer nb_item_in_group = m_wrapper.cellGroupNbCell(lima_group);
        std::string group_name = lima_group.nom();
        unique_ids.resize(nb_item_in_group);
        local_ids.resize(nb_item_in_group);
        for (Integer z = 0; z < nb_item_in_group; ++z) {
          unique_ids[z] = cells_unique_id[CheckedConvert::toInteger(m_wrapper.cellCellGroup(lima_group, z).id() - 1)];
        }
        mesh->cellFamily()->itemsUniqueIdToLocalId(local_ids, unique_ids);
        bool remove_group = false;
        if (group_name == "LOCAL" || group_name == "local") {
          ItemInternalList cells(mesh->itemsInternal(IK_Cell));
          for (Integer z = 0, sz = nb_item_in_group; z < sz; ++z)
            cells[local_ids[z]]->setOwner(sub_domain_id, sub_domain_id);
          remove_group = true;
        }
        if (!remove_group) {
          String grp(group_name.c_str());
          if (grp.startsWith("MF_")) {
            info() << "Le groupe de mailles " << group_name << " n'est pas utilisé";
            remove_group = true;
          }
        }
        if (!remove_group) {
          log() << "CellGroup Name <" << group_name << "> (" << nb_item_in_group << " elements)";
          LimaUtils::createGroup(cell_family, group_name, local_ids);
        }
      }
    }
  }
 
  {
    // Fills the variable containing the node coordinates
    // In parallel with the mesh already cut by Decoupe3D, the
    // mesh already contains a layer of ghost cells. To
    // have the node coordinates if we only need one layer
    // of ghost cells, it is enough to iterate over all
    // nodes. If we need multiple layers of ghost cells,
    // synchronization must be performed.
    VariableNodeReal3& nodes_coord_var(mesh->nodesCoordinates());
    NodeGroup nodes = mesh->allNodes();
    Integer nb_ghost_layer = mesh->ghostLayerMng()->nbGhostLayer();
    if (nb_ghost_layer > 1)
      nodes = mesh->ownNodes();
    ENUMERATE_NODE (i, nodes) {
      const Node& node = *i;
      nodes_coord_var[node] = nodes_coords.lookupValue(node.uniqueId());
      //info() << "Coord: " << node.uniqueId() << " v=" << nodes_coord_var[node];
    }
    if (nb_ghost_layer > 1)
      nodes_coord_var.synchronize();
  }
 
  //    -------------------------------- Reading groups
  info() << "Nombre de nuages   " << lima.nb_nuages();
  info() << "Nombre de lignes   " << lima.nb_lignes();
  info() << "Nombre de surfaces " << lima.nb_surfaces();
  info() << "Nombre de volumes  " << lima.nb_volumes();
 
  //    -------------------------------- Creation of internal structures.
 
  //_buildInternalMesh();
 
  logdate() << "Fin de lecture du fichier";
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename ReaderWrapper> void LimaWrapper<ReaderWrapper>::
_getProcList(UniqueArray<Integer>& proc_list, const String& dir_name)
{
  ISubDomain* sd = subDomain();
  StringBuilder comm_file_nameb;
  if (!dir_name.empty()) {
    comm_file_nameb += dir_name;
    comm_file_nameb += "/";
  }
  comm_file_nameb += "Communications";
  String comm_file_name = comm_file_nameb.toString();
 
  // Reading the communication file
  ScopedPtrT<IXmlDocumentHolder> doc_holder(sd->ioMng()->parseXmlFile(comm_file_name));
  if (!doc_holder.get())
    ARCANE_FATAL("Invalid file '{0}'", comm_file_name);
 
  XmlNode root_elem = doc_holder->documentNode().documentElement();
  XmlNode cpu_elem;
  XmlNodeList cpu_list = root_elem.child(String("cpus")).children(String("cpu-from"));
 
  String ustr_buf = String::fromNumber(sd->subDomainId());
  String ustr_id(String("id"));
  for (Integer i = 0, s = cpu_list.size(); i < s; ++i) {
    String id_str = cpu_list[i].attrValue(ustr_id);
    if (id_str == ustr_buf) {
      cpu_elem = cpu_list[i];
      break;
    }
  }
  if (cpu_elem.null())
    ARCANE_FATAL("No element <cpus/cpu-from[@id=\"{0}\"]>", sd->subDomainId());
  {
    cpu_list = cpu_elem.children(String("cpu-to"));
    debug() << "Nb procs " << cpu_list.size();
    for (Integer i = 0; i < cpu_list.size(); ++i) {
      Integer v = cpu_list[i].valueAsInteger();
      proc_list.add(v);
      debug() << "Read proc " << v;
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class LimaCaseMeshReader
: public AbstractService
, public ICaseMeshReader
{
 public:
 
  class Builder
  : public IMeshBuilder
  {
   public:
 
    explicit Builder(ISubDomain* sd, const CaseMeshReaderReadInfo& read_info)
    : m_sub_domain(sd)
    , m_trace_mng(sd->traceMng())
    , m_read_info(read_info)
    {}
 
   public:
 
    void fillMeshBuildInfo(MeshBuildInfo& build_info) override
    {
      ARCANE_UNUSED(build_info);
    }
    void allocateMeshItems(IPrimaryMesh* pm) override
    {
      LimaMeshReader reader(m_sub_domain);
      String fname = m_read_info.fileName();
      m_trace_mng->info() << "Lima Reader (ICaseMeshReader) file_name=" << fname;
      bool use_length_unit = true; // With ICaseMeshReader, we always use the unit system.
      String directory_name = m_read_info.directoryName();
      IMeshReader::eReturnType ret = reader.readMesh(pm, fname, directory_name, m_read_info.isParallelRead(), use_length_unit);
      if (ret != IMeshReader::RTOk)
        ARCANE_FATAL("Can not read MSH File");
    }
 
   private:
 
    ISubDomain* m_sub_domain;
    ITraceMng* m_trace_mng;
    CaseMeshReaderReadInfo m_read_info;
  };
 
 public:
 
  explicit LimaCaseMeshReader(const ServiceBuildInfo& sbi)
  : AbstractService(sbi)
  , m_sub_domain(sbi.subDomain())
  {}
 
 public:
 
  Ref<IMeshBuilder> createBuilder(const CaseMeshReaderReadInfo& read_info) const override
  {
    IMeshBuilder* builder = nullptr;
    String str = read_info.format();
    if (str == "unf" || str == "mli" || str == "mli2" || str == "ice" || str == "uns" || str == "unv")
      builder = new Builder(m_sub_domain, read_info);
    return makeRef(builder);
  }
 
 private:
 
  ISubDomain* m_sub_domain = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE(LimaCaseMeshReader,
                        ServiceProperty("LimaCaseMeshReader", ST_SubDomain),
                        ARCANE_SERVICE_INTERFACE(ICaseMeshReader));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class LimaMeshWriter
: public AbstractService
, public IMeshWriter
{
 public:
 
  LimaMeshWriter(const ServiceBuildInfo& sbi)
  : AbstractService(sbi)
  , m_sub_domain(sbi.subDomain())
  {}
 
 public:
 
  virtual void build() {}
  virtual bool writeMeshToFile(IMesh* mesh, const String& file_name);
 
 private:
 
  ISubDomain* m_sub_domain;
  void _writeItem(Lima::Maillage& lima_mesh, ConstArrayView<Lima::Noeud> nodes,
                  ItemWithNodes item);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE(LimaMeshWriter,
                        ServiceProperty("Lima", ST_SubDomain),
                        ARCANE_SERVICE_INTERFACE(IMeshWriter));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void LimaMeshWriter::
_writeItem(Lima::Maillage& m, ConstArrayView<Lima::Noeud> nodes, ItemWithNodes c)
{
  switch (c.type()) {
  case IT_Octaedron12:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()], nodes[c.node(5).localId()],
                             nodes[c.node(6).localId()], nodes[c.node(7).localId()],
                             nodes[c.node(8).localId()], nodes[c.node(9).localId()],
                             nodes[c.node(10).localId()], nodes[c.node(11).localId()]));
    break;
  case IT_Heptaedron10:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()], nodes[c.node(5).localId()],
                             nodes[c.node(6).localId()], nodes[c.node(7).localId()],
                             nodes[c.node(8).localId()], nodes[c.node(9).localId()]));
    break;
  case IT_Hexaedron8:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()], nodes[c.node(5).localId()],
                             nodes[c.node(6).localId()], nodes[c.node(7).localId()]));
    break;
  case IT_Pentaedron6:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()], nodes[c.node(5).localId()]));
    break;
  case IT_Pyramid5:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()]));
    break;
  case IT_Tetraedron4:
    m.ajouter(Lima::Polyedre(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()]));
    break;
  case IT_Hexagon6:
    m.ajouter(Lima::Polygone(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()], nodes[c.node(5).localId()]));
    break;
  case IT_Pentagon5:
    m.ajouter(Lima::Polygone(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()],
                             nodes[c.node(4).localId()]));
    break;
  case IT_Quad4:
    m.ajouter(Lima::Polygone(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()], nodes[c.node(3).localId()]));
    break;
  case IT_Triangle3:
    m.ajouter(Lima::Polygone(nodes[c.node(0).localId()], nodes[c.node(1).localId()],
                             nodes[c.node(2).localId()]));
    break;
  case IT_Line2:
    m.ajouter(Lima::Bras(nodes[c.node(0).localId()], nodes[c.node(1).localId()]));
    break;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
bool LimaMeshWriter::
writeMeshToFile(IMesh* mesh, const String& file_name)
{
  ITraceMng* trace = mesh->traceMng();
  int dimension = mesh->dimension();
 
  std::string std_file_name = file_name.localstr();
  //TODO: ADD EXTENSION if not present
  // Check if the file has the extension '.unf', '.mli', or '.mli2'.
  // Otherwise, add '.mli2'
  const size_t rpos2 = std_file_name.rfind(".mli2");
  std::string::size_type std_end = std::string::npos;
  bool need_mutex = rpos2 != std_end;
  if (rpos2 == std_end && std_file_name.rfind(".mli") == std_end && std_file_name.rfind(".unf") == std_end) {
    std_file_name += ".mli2";
    need_mutex = true;
  }
  info() << "FINAL_FILE_NAME=" << std_file_name;
  Lima::Maillage lima(std_file_name);
 
  if (dimension == 3)
    lima.dimension(Lima::D3);
  else if (dimension == 2)
    lima.dimension(Lima::D2);
 
  IItemFamily* node_family = mesh->nodeFamily();
  IItemFamily* edge_family = mesh->edgeFamily();
  IItemFamily* face_family = mesh->faceFamily();
  IItemFamily* cell_family = mesh->cellFamily();
 
  Integer mesh_nb_node = node_family->nbItem();
  Integer mesh_nb_edge = edge_family->nbItem();
  Integer mesh_nb_face = face_family->nbItem();
  Integer mesh_nb_cell = cell_family->nbItem();
 
  NodeInfoListView nodes(node_family);
  EdgeInfoListView edges(edge_family);
  FaceInfoListView faces(face_family);
  CellInfoListView cells(cell_family);
 
  UniqueArray<Lima::Noeud> lm_nodes(mesh_nb_node);
 
  VariableItemReal3& nodes_coords = mesh->nodesCoordinates();
 
  // Save nodes
  for (Integer i = 0; i < mesh_nb_node; ++i) {
    Node node = nodes[i];
    Real3 coord = nodes_coords[node];
    lm_nodes[i].set_x(Convert::toDouble(coord.x));
    lm_nodes[i].set_y(Convert::toDouble(coord.y));
    lm_nodes[i].set_z(Convert::toDouble(coord.z));
    lima.ajouter(lm_nodes[i]);
  }
 
  // Save edges
  for (Integer i = 0; i < mesh_nb_edge; ++i) {
    _writeItem(lima, lm_nodes, edges[i]);
  }
 
  // Save faces
  for (Integer i = 0; i < mesh_nb_face; ++i) {
    _writeItem(lima, lm_nodes, faces[i]);
  }
 
  // Save cells
  for (Integer i = 0; i < mesh_nb_cell; ++i) {
    _writeItem(lima, lm_nodes, cells[i]);
  }
 
  try {
 
    // Save node groups
    for (ItemGroupCollection::Enumerator i(node_family->groups()); ++i;) {
      ItemGroup group = *i;
      if (group.isAllItems())
        continue;
      Lima::Nuage lm_group(group.name().localstr());
      lima.ajouter(lm_group);
      ENUMERATE_ITEM (iitem, group) {
        lm_group.ajouter(lima.noeud(iitem.localId()));
      }
    }
 
    // Save edge groups
    for (ItemGroupCollection::Enumerator i(edge_family->groups()); ++i;) {
      ItemGroup group = *i;
      if (group.isAllItems())
        continue;
      Lima::Ligne lm_group(group.name().localstr());
      lima.ajouter(lm_group);
      ENUMERATE_ITEM (iitem, group) {
        lm_group.ajouter(lima.bras(iitem.localId()));
      }
    }
 
    // Save face groups
    for (ItemGroupCollection::Enumerator i(face_family->groups()); ++i;) {
      ItemGroup group = *i;
      if (group.isAllItems())
        continue;
      if (dimension == 3) {
        Lima::Surface lm_group(group.name().localstr());
        lima.ajouter(lm_group);
        ENUMERATE_ITEM (iitem, group) {
          lm_group.ajouter(lima.polygone(iitem.localId()));
        }
      }
      else if (dimension == 2) {
        Lima::Ligne lm_group(group.name().localstr());
        lima.ajouter(lm_group);
        ENUMERATE_ITEM (iitem, group) {
          lm_group.ajouter(lima.bras(iitem.localId()));
        }
      }
    }
 
    // Save cell groups
    for (ItemGroupCollection::Enumerator i(cell_family->groups()); ++i;) {
      ItemGroup group = *i;
      if (group.isAllItems())
        continue;
      if (dimension == 3) {
        Lima::Volume lm_group(group.name().localstr());
        lima.ajouter(lm_group);
        ENUMERATE_ITEM (iitem, group) {
          lm_group.ajouter(lima.polyedre(iitem.localId()));
        }
      }
      else if (dimension == 2) {
        Lima::Surface lm_group(group.name().localstr());
        lima.ajouter(lm_group);
        ENUMERATE_ITEM (iitem, group) {
          lm_group.ajouter(lima.polygone(iitem.localId()));
        }
      }
    }
    info(4) << "Writing file '" << std_file_name << "'";
 
    {
      GlobalLimaMutex sc(need_mutex);
      lima.ecrire(std_file_name);
    }
  }
  catch (const std::exception& ex) {
    trace->warning() << "Exception (std::exception) in LIMA: Can not write file <" << std_file_name << ">"
                     << " Exception: " << ex.what() << '\n';
    return true;
  }
  catch (...) {
    trace->warning() << "Exception (unknown) in LIMA: Can not write file <" << std_file_name << ">";
    return true;
  }
 
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/