MEDMeshReaderService.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MEDMeshReaderService.cc                                     (C) 2000-2026 */
/*                                                                           */
/* Lecture d'un maillage au format MED.                                      */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/SmallArray.h"
#include "arcane/utils/FixedArray.h"
#include "arcane/utils/Convert.h"
#include "arcane/utils/CheckedConvert.h"
 
#include "arcane/core/IMeshReader.h"
#include "arcane/core/BasicService.h"
#include "arcane/core/ServiceFactory.h"
#include "arcane/core/IPrimaryMesh.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/ICaseMeshReader.h"
#include "arcane/core/IMeshBuilder.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/MeshPartInfo.h"
#include "arcane/core/NodesOfItemReorderer.h"
#include "arcane/core/MeshUtils.h"
#include "arcane/core/ItemPrinter.h"
#include "arcane/core/internal/ItemTypeMngInternal.h"
 
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
 
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class MEDMeshReader
: public TraceAccessor
{
 public:

  class MEDToArcaneItemInfo
  {
   public:
 
    MEDToArcaneItemInfo(int dimension, int nb_node, med_int med_type,
                        ItemTypeId arcane_type, const Int32* indirection)
    : m_dimension(dimension)
    , m_nb_node(nb_node)
    , m_med_type(med_type)
    , m_arcane_type(arcane_type)
    , m_indirection(indirection)
    {}
 
   public:
 
    int dimension() const { return m_dimension; }
    int nbNode() const { return m_nb_node; }
    med_int medType() const { return m_med_type; }
    Int16 arcaneType() const { return m_arcane_type; }
    const Int32* indirection() const { return m_indirection; }
 
   private:
 
    int m_dimension = -1;
    int m_nb_node = -1;
    med_int m_med_type = {};
    ItemTypeId m_arcane_type = ITI_NullType;
    const Int32* m_indirection = nullptr;
  };

  class MEDFamilyInfo
  {
   public:
 
    explicit MEDFamilyInfo(Int32 family_id)
    : m_family_id(family_id)
    {}
 
   public:

    Int32 m_family_id = 0;
    Int32 m_index = -1;
  };

  class MEDGroupInfo
  {
   public:
 
    explicit MEDGroupInfo(Int32 index)
    : m_index(index)
    {}
 
   public:

    Int32 m_index = -1;
    UniqueArray<String> m_names;
    UniqueArray<Int64> m_unique_ids;
    UniqueArray<Int32> m_local_ids;
  };
 
 public:
 
  explicit MEDMeshReader(ITraceMng* tm)
  : TraceAccessor(tm)
  {
    _initMEDToArcaneTypes();
  }
 
 public:
 
  [[nodiscard]] IMeshReader::eReturnType
  readMesh(IPrimaryMesh* mesh, const String& file_name);
 
 private:
 
  IMeshReader::eReturnType _readMesh(IPrimaryMesh* mesh, const String& filename);
 
 private:
 
  // Structure pour fermer automatiquement les fichiers MED ouverts
  struct AutoCloseMED
  {
    explicit AutoCloseMED(med_idt id)
    : fid(id)
    {}
    ~AutoCloseMED()
    {
      if (fid >= 0)
        ::MEDfileClose(fid);
    }
 
    med_idt fid;
  };

  IPrimaryMesh* m_mesh = nullptr;
  UniqueArray<MEDToArcaneItemInfo> m_med_to_arcane_types;
  std::unordered_map<med_int, Int32> m_med_geotype_to_arcane_type_index;
  std::unordered_map<Int32, MEDFamilyInfo> m_med_families_map;
  UniqueArray<MEDGroupInfo> m_med_groups;
  UniqueArray<med_int> m_med_geotypes_in_mesh;
 
 private:
 
  Int32 _readItems(IPrimaryMesh* mesh, med_idt fid, const char* meshnane, const MEDToArcaneItemInfo& iinfo,
                   Array<Int16>& poly_nb_nodes, Array<Int16>& poly_types, Array<med_int>& connectivity, Array<med_int>& family_values);
  void _initMEDToArcaneTypes();
  void _addTypeInfo(int dimension, int nb_node, med_int med_type, ItemTypeId arcane_type)
  {
    _addTypeInfo(dimension, nb_node, med_type, arcane_type, nullptr);
  }
  void _addTypeInfo(int dimension, int nb_node, med_int med_type, ItemTypeId arcane_type,
                    const Int32* indirection)
  {
    MEDToArcaneItemInfo t(dimension, nb_node, med_type, arcane_type, indirection);
    Int32 index = m_med_to_arcane_types.size();
    m_med_to_arcane_types.add(t);
    m_med_geotype_to_arcane_type_index.insert(std::make_pair(med_type, index));
  }
  void _readAndCreateCells(IPrimaryMesh* mesh, Int32 mesh_dimension, med_idt fid, const char* meshname);
  void _readFaces(IPrimaryMesh* mesh, Int32 mesh_dimension, med_idt fid, const char* meshname);
 
  [[nodiscard]] IMeshReader::eReturnType
  _readNodesCoordinates(IPrimaryMesh* mesh, Int64 nb_node, Int32 spacedim,
                        med_idt fid, const char* meshname);
  void _readFamilies(med_idt fid, const char* meshname);
  void _readAvailableTypes(med_idt fid, const char* meshname);
  void _clearItemsInGroups()
  {
    for (MEDGroupInfo& g : m_med_groups) {
      g.m_unique_ids.clear();
      g.m_local_ids.clear();
    }
  }
  void _broadcastGroups(ConstArrayView<String> names, IItemFamily* family);
  med_int _readPolyhedrons(IPrimaryMesh* mesh, med_idt fid, const char* meshname,
                           Array<Int16>& poly_nb_nodes,
                           Array<Int16>& poly_types_id,
                           Array<med_int>& connectivity);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
  // Les conventions de numérotations de MED sont différentes de celles
  // utilisées dans Arcane. Ces tableaux permettent d'effectuer la renumérotation.
  const Int32 Hexaedron8_indirection[] = { 1, 0, 3, 2, 5, 4, 7, 6 };
  const Int32 Hexaedron20_indirection[] = { 1, 8, 10, 3, 9, 2, 0, 11, 5, 14, 18, 7, 6, 4, 16, 15, 13, 12, 17, 19 };
  const Int32 Pyramid5_indirection[] = { 1, 0, 3, 2, 4 };
  const Int32 Quad4_indirection[] = { 1, 0, 3, 2 };
  const Int32 Quad8_indirection[] = { 1, 0, 3, 2, 4, 7, 6, 5 };
  const Int32 Triangle3_indirection[] = { 1, 0, 2 };
  // PAS utilisé pour l'instant. À tester.
  const Int32 Tetraedron4_indirection[] = { 1, 0, 2, 3 };
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MEDMeshReader::
_initMEDToArcaneTypes()
{
  m_med_to_arcane_types.clear();
 
  // TODO: regarder la correspondance de connectivité entre
  // Arcane et MED pour les éléments quadratiques
  // Types 1D
  _addTypeInfo(1, 2, MED_SEG2, ITI_Line2);
  _addTypeInfo(1, 3, MED_SEG3, ITI_Line3); // Non supporté
  _addTypeInfo(1, 4, MED_SEG4, ITI_NullType); // Non supporté
 
  // Types 2D.
  _addTypeInfo(2, 3, MED_TRIA3, ITI_Triangle3, Triangle3_indirection);
  _addTypeInfo(2, 4, MED_QUAD4, ITI_Quad4, Quad4_indirection);
  _addTypeInfo(2, 6, MED_TRIA6, ITI_NullType); // Non supporté
  _addTypeInfo(2, 7, MED_TRIA7, ITI_NullType); // Non supporté
  _addTypeInfo(2, 8, MED_QUAD8, ITI_Quad8, Quad8_indirection);
  _addTypeInfo(2, 9, MED_QUAD9, ITI_NullType); // Non supporté
 
  // Types 3D
  _addTypeInfo(3, 4, MED_TETRA4, ITI_Tetraedron4);
  _addTypeInfo(3, 5, MED_PYRA5, ITI_Pyramid5, Pyramid5_indirection);
  _addTypeInfo(3, 6, MED_PENTA6, ITI_Pentaedron6);
  _addTypeInfo(3, 8, MED_HEXA8, ITI_Hexaedron8);
  _addTypeInfo(3, 10, MED_TETRA10, ITI_Tetraedron10);
  _addTypeInfo(3, 12, MED_OCTA12, ITI_Octaedron12);
  _addTypeInfo(3, 13, MED_PYRA13, ITI_NullType); // Non supporté
  _addTypeInfo(3, 15, MED_PENTA15, ITI_NullType); // Non supporté
  _addTypeInfo(3, 18, MED_PENTA18, ITI_NullType); // Non supporté
  _addTypeInfo(3, 20, MED_HEXA20, ITI_Hexaedron20);
  _addTypeInfo(3, 27, MED_HEXA27, ITI_NullType); // Non supporté
 
  // Mailles dont la géométrie à une connectivité variable.
  // Pour l'instant, on ne supporte aucun de ces types dans Arcane.
  // On traite quand même ces éléments pour afficher une erreur s'ils sont
  // présents dans le maillage. En mettant la valeur (0) pour le nombre
  // de noeuds, on signale à _readItems() qu'on ne sait pas traiter ces éléments.
 
  _addTypeInfo(2, 0, MED_POLYGON, ITI_GenericPolygon);
  _addTypeInfo(2, 0, MED_POLYGON2, ITI_NullType);
  _addTypeInfo(3, 0, MED_POLYHEDRON, ITI_GenericPolyhedron);
 
  // Mailles dont la géométrie est dynamique (découverte du modèle dans le fichier)
  // TODO: regarder comment les traiter
  //#define MED_STRUCT_GEO_INTERNAL 600
  //#define MED_STRUCT_GEO_SUP_INTERNAL 700
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshReader::eReturnType MEDMeshReader::
readMesh(IPrimaryMesh* mesh, const String& file_name)
{
  info() << "Tentative de lecture du fichier MED nommé=" << file_name;
  m_mesh = mesh;
  return _readMesh(mesh, file_name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshReader::eReturnType MEDMeshReader::
_readMesh(IPrimaryMesh* mesh, const String& filename)
{
  const med_idt fid = MEDfileOpen(filename.localstr(), MED_ACC_RDONLY);
  if (fid < 0) {
    MESSAGE("ERROR: can not open MED file ");
    error() << "ERROR: can not open MED file '" << filename << "'";
    return IMeshReader::RTError;
  }
  // Pour garantir la fermeture du fichier.
  AutoCloseMED auto_close_med(fid);
 
  int nb_mesh = MEDnMesh(fid);
  if (nb_mesh < 0) {
    error() << "Erreur lors de la lecture du nombre de maillages";
    return IMeshReader::RTError;
  }
  info() << "MED: nb_mesh=" << nb_mesh;
  if (nb_mesh == 0) {
    error() << "Aucun maillage n'est présent";
    return IMeshReader::RTError;
  }
 
  // Le maillage qu'on lit est toujours le premier
  int mesh_index = 1;
 
  // Récupère la dimension d'espace. Cela est nécessaire pour dimensionner axisname et unitname
  int nb_axis = MEDmeshnAxis(fid, mesh_index);
  if (nb_axis < 0) {
    error() << "Impossible de lire le nombre d'axes (MEDmeshnAxis)";
    return IMeshReader::RTError;
  }
  info() << "MED: nb_axis=" << nb_axis;
 
  UniqueArray<char> axisname(MED_SNAME_SIZE * nb_axis + 1, '\0');
  UniqueArray<char> unitname(MED_SNAME_SIZE * nb_axis + 1, '\0');
 
  char meshname[MED_NAME_SIZE + 1];
  meshname[0] = '\0';
  char meshdescription[MED_COMMENT_SIZE + 1];
  meshdescription[0] = '\0';
  char dtunit[MED_SNAME_SIZE + 1];
  dtunit[0] = '\0';
  med_int spacedim = 0;
  med_int meshdim = 0;
  med_mesh_type meshtype = MED_UNDEF_MESH_TYPE;
  med_sorting_type sortingtype = MED_SORT_UNDEF;
  med_int nstep = 0;
  med_axis_type axistype = MED_UNDEF_AXIS_TYPE;
  int err = 0;
  err = MEDmeshInfo(fid, mesh_index, meshname, &spacedim, &meshdim, &meshtype, meshdescription,
                    dtunit, &sortingtype, &nstep, &axistype, axisname.data(), unitname.data());
  if (err < 0) {
    error() << "Impossible de lire les informations du maillage (MEDmeshInfo) r=" << err;
    return IMeshReader::RTError;
  }
  if (meshtype != MED_UNSTRUCTURED_MESH) {
    error() << "Arcane ne gère que les maillages non structurés MED (MED_UNSTRUCTURED_MESH) type=" << meshtype;
    return IMeshReader::RTError;
  }
  Integer mesh_dimension = meshdim;
  if (mesh_dimension != 2 && mesh_dimension != 3)
    ARCANE_FATAL("Le lecteur MED ne gère que les maillages 2D ou 3D");
 
  info() << "MED: name=" << meshname;
  info() << "MED: description=" << meshdescription;
  info() << "MED: spacedim=" << spacedim;
  info() << "MED: meshdim=" << meshdim;
  info() << "MED: dtunit=" << dtunit;
  info() << "MED: meshtype=" << meshtype;
  info() << "MED: sortingtype=" << sortingtype;
  info() << "MED: axistype=" << axistype;
  info() << "MED: nstep=" << nstep;
 
  Int64 nb_node = 0;
  // Lecture du nombre de noeuds.
  {
    med_bool coordinatechangement;
    med_bool geotransformation;
    // TODO: traiter les informations telles que coordinatechangement
    // et geotransformation si besoin
    med_int med_nb_node = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NO_GEOTYPE,
                                         MED_COORDINATE, MED_NO_CMODE, &coordinatechangement,
                                         &geotransformation);
    if (med_nb_node < 0) {
      error() << "Impossible de lire le nombre de nœuds (MEDmeshnEntity) err=" << med_nb_node;
      return IMeshReader::RTError;
    }
    nb_node = med_nb_node;
  }
  info() << "MED: nb_node=" << nb_node;
 
  mesh->setDimension(mesh_dimension);
 
  // Les maillages MED peuvent contenir des polygones ou des polyèdres.
  // On construit donc les types correspondants.
  // (NOTE : tous les sous-domaines doivent faire cela)
  mesh->itemTypeMng()->buildPolygonTypes();
 
  IParallelMng* pm = mesh->parallelMng();
  bool is_parallel = pm->isParallel();
  Int32 rank = mesh->meshPartInfo().partRank();
  // En parallèle, seul le rang 0 lit le maillage
  bool is_read_items = !(is_parallel && rank != 0);
  if (is_read_items) {
    _readAvailableTypes(fid, meshname);
    _readFamilies(fid, meshname);
    _readAndCreateCells(mesh, mesh_dimension, fid, meshname);
  }
  // La méthode IPrimaryMesh::endAllocate() est collective donc tout
  // le monde doit l'appeler même si les rangs autres que le rang 0
  // qui n'ont pas de mailles.
  mesh->endAllocate();
 
  // Liste des noms des groupes de mailles créées
  // Elle servira à transférer la liste des groupes à tous les rangs.
  UniqueArray<String> cell_group_names;
  IItemFamily* cell_family = mesh->cellFamily();
  if (is_read_items) {
    // Maintenant qu'on a créé toutes les mailles, on crée les groupes correspondants
    // Pour cela, on parcourt toutes les instances de 'm_med_groups' et si une a des entités
    // alors ce sont des mailles à ajouter à un groupe.
    // ATTENTION ATTENTION:
    // NOTE: Les groupes doivent être communs à tous les rangs. Il faut les broadcaster
    UniqueArray<Int32> cell_local_ids;
    for (const MEDGroupInfo& g : m_med_groups) {
      Int32 nb_cell_in_group = g.m_unique_ids.size();
      cell_local_ids.resize(nb_cell_in_group);
      cell_family->itemsUniqueIdToLocalId(cell_local_ids, g.m_unique_ids);
      for (const String& name : g.m_names) {
        info() << "Group=" << name << " index=" << g.m_index << " nb_item=" << nb_cell_in_group;
        CellGroup cell_group = cell_family->findGroup(name, true);
        cell_group.addItems(cell_local_ids);
        cell_group_names.add(name);
      }
    }
  }
  _broadcastGroups(cell_group_names, cell_family);
 
  // Lit les faces
  if (is_read_items) {
    // Comme la numérotation des faces n'est pas forcément correcte pour tous
    // les types d'entités (notamment pour l'ordre 2), on ajoute une option pour
    // ne pas lire les faces.
    bool is_face_group_disabled = false;
    if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_MED_DISABLE_FACEGROUP", true))
      is_face_group_disabled = (v.value());
    if (!is_face_group_disabled)
      _readFaces(mesh, mesh_dimension, fid, meshname);
  }
 
  UniqueArray<String> face_group_names;
  IItemFamily* face_family = mesh->faceFamily();
  // Maintenant ajoute les faces aux groupes.
  if (is_read_items) {
    for (const MEDGroupInfo& g : m_med_groups) {
      Int32 nb_face_in_group = g.m_local_ids.size();
      info() << "Vérification du groupe index=" << g.m_index << " nb_item=" << nb_face_in_group;
      if (nb_face_in_group == 0)
        continue;
      for (const String& name : g.m_names) {
        info() << "FaceGroup=" << name << " index=" << g.m_index << " nb_item=" << nb_face_in_group;
        FaceGroup face_group = face_family->findGroup(name, true);
        face_group.addItems(g.m_local_ids);
        face_group_names.add(name);
      }
    }
  }
  _broadcastGroups(face_group_names, face_family);
 
  if (is_read_items) {
    // Lit les coordonnées
    return _readNodesCoordinates(mesh, nb_node, spacedim, fid, meshname);
  }
  return IMeshReader::RTOk;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void MEDMeshReader::
_readAvailableTypes(med_idt fid, const char* meshname)
{
  // Récupère le nombre de types géométriques
  med_bool coordinatechangement;
  med_bool geotransformation;
  med_int nb_geo = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, MED_GEO_ALL,
                                  MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
                                  &geotransformation);
  if (nb_geo < 0)
    ARCANE_FATAL("Impossible de lire le nombre d'entités géométriques nb_geo={0}", nb_geo);
  info() << "MED: nb_geotype = " << nb_geo;
 
  // Boucle sur les types présents
  for (med_int it = 1; it <= nb_geo; it++) {
 
    med_geometry_type geotype = MED_GEO_ALL;
    FixedArray<char, MED_NAME_SIZE + 1> geotype_name;
 
    /* get geometry type */
    med_int type_ret = MEDmeshEntityInfo(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, it,
                                         geotype_name.data(), &geotype);
    if (type_ret < 0)
      ARCANE_FATAL("Impossible de lire les informations pour le géotype index={0} ret={1}", it, type_ret);
    /* combien de mailles de type géotype ? */
    med_int nb_item = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, geotype,
                                     MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
                                     &geotransformation);
    if (nb_item < 0)
      ARCANE_FATAL("Impossible de lire le nombre d'éléments pour le géotype={0} nom={1} ret={2}",
                   geotype, geotype_name.data(), nb_item);
    info() << "MED: type=" << geotype << " '" << geotype_name.data() << "' nb_item=" << nb_item;
    m_med_geotypes_in_mesh.add(geotype);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MEDMeshReader::
_readAndCreateCells(IPrimaryMesh* mesh, Int32 mesh_dimension, med_idt fid, const char* meshname)
{
  _clearItemsInGroups();
 
  // A priori il n'y a pas de uniqueId() pour les entités dans MED (TODO: à vérifier)
  // Donc on numérote les mailles en commencant par zéro et on incrémente à chaque
  // maille créée.
  Int64 cell_unique_id = 0;
 
  // Nombre de noeuds pour chaque polygone ou polyèdre
  UniqueArray<Int16> poly_nb_nodes;
  // Type de chaque polygone ou polyèdre
  UniqueArray<Int16> poly_types_id;
  UniqueArray<med_int> med_connectivity;
  UniqueArray<med_int> med_family_values;
 
  // Alloue les mailles types par type.
  // Parcours les types disponibles et traite ceux qui correspondent à la dimension
  // du maillage.
  for (med_int geotype : m_med_geotypes_in_mesh) {
    Int32 index_in_list = m_med_geotype_to_arcane_type_index[geotype];
    const MEDToArcaneItemInfo& iinfo = m_med_to_arcane_types[index_in_list];
 
    Int32 item_dimension = iinfo.dimension();
    // On ne traite que les entités de la dimension du maillage.
    if (item_dimension != mesh_dimension)
      continue;
    Int32 nb_item = _readItems(mesh, fid, meshname, iinfo, poly_nb_nodes, poly_types_id, med_connectivity, med_family_values);
    if (nb_item == 0)
      continue;
 
    Int16 arcane_type = iinfo.arcaneType();
    Int32 nb_item_node = iinfo.nbNode();
    Int32 nb_family_values = med_family_values.size();
    if (arcane_type == IT_NullType) {
      // Indique un type pris en charge par MED mais pas par Arcane
      ARCANE_FATAL("Le type MED '{0}' n'est pas pris en charge par Arcane", iinfo.medType());
    }
    Int64 cells_infos_index = 0;
    Int64 med_connectivity_index = 0;
    const bool is_poly = (iinfo.medType() == MED_POLYGON) || (iinfo.medType() == MED_POLYHEDRON);
    // Indique que le maillage possède des mailles polygones ou polyèdres.
    if (is_poly)
      mesh->itemTypeMng()->setMeshWithGeneralCells(mesh);
    UniqueArray<Int64> cells_infos;
    if (is_poly)
      cells_infos.resize(2 * nb_item + med_connectivity.size());
    else
      cells_infos.resize((2 + nb_item_node) * nb_item);
 
    info() << "CELL_INFOS size=" << cells_infos.size() << " nb_item=" << nb_item
           << " type=" << arcane_type;
 
    const Int32* indirection = iinfo.indirection();
    for (Int32 i = 0; i < nb_item; ++i) {
      Int64 current_cell_unique_id = cell_unique_id;
      ++cell_unique_id;
      if (is_poly) {
        nb_item_node = poly_nb_nodes[i];
        arcane_type = poly_types_id[i];
        cells_infos[cells_infos_index] = arcane_type;
        ++cells_infos_index;
        cells_infos[cells_infos_index] = current_cell_unique_id;
        ++cells_infos_index;
        Span<Int64> cinfo_span(cells_infos.span().subspan(cells_infos_index, nb_item_node));
        Span<med_int> med_cinfo_span(med_connectivity.span().subspan(med_connectivity_index, nb_item_node));
        for (Integer k = 0; k < nb_item_node; ++k) {
          cinfo_span[k] = med_cinfo_span[k];
        }
      }
      else {
        cells_infos[cells_infos_index] = arcane_type;
        ++cells_infos_index;
        cells_infos[cells_infos_index] = current_cell_unique_id;
        ++cells_infos_index;
        Span<Int64> cinfo_span(cells_infos.span().subspan(cells_infos_index, nb_item_node));
        Span<med_int> med_cinfo_span(med_connectivity.span().subspan(med_connectivity_index, nb_item_node));
        if (indirection) {
          for (Integer k = 0; k < nb_item_node; ++k) {
            cinfo_span[k] = med_cinfo_span[indirection[k]];
          }
        }
        else {
          for (Integer k = 0; k < nb_item_node; ++k)
            cinfo_span[k] = med_cinfo_span[k];
        }
      }
      if (i < nb_family_values) {
        // Il y a une famille associée à l'entité
        med_int f = med_family_values[i];
        auto x = m_med_families_map.find(f);
        if (x == m_med_families_map.end()) {
          ARCANE_FATAL("Impossible de trouver l'ID de famille '{0}' pour la maille '{1}' de géotype '{2}'",
                       f, i, iinfo.medType());
        }
        m_med_groups[x->second.m_index].m_unique_ids.add(current_cell_unique_id);
      }
 
      med_connectivity_index += nb_item_node;
      cells_infos_index += nb_item_node;
    }
    mesh->allocateCells(nb_item, cells_infos, false);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void MEDMeshReader::
_readFaces(IPrimaryMesh* mesh, Int32 mesh_dimension, med_idt fid, const char* meshname)
{
  _clearItemsInGroups();
  ItemTypeMng* itm = mesh->itemTypeMng();
  NodesOfItemReorderer nodes_reorderer(itm);
 
  IItemFamily* node_family = mesh->nodeFamily();
  NodeInfoListView mesh_nodes(node_family);
 
  UniqueArray<Int16> poly_nb_nodes;
  UniqueArray<Int16> poly_types_id;
  UniqueArray<med_int> med_connectivity;
  UniqueArray<med_int> med_family_values;
  // Parcours les types disponibles et traite ceux qui correspondent à la dimension
  // du maillage moins 1.
  for (med_int geotype : m_med_geotypes_in_mesh) {
    Int32 index_in_list = m_med_geotype_to_arcane_type_index[geotype];
    const MEDToArcaneItemInfo& iinfo = m_med_to_arcane_types[index_in_list];
 
    Int32 item_dimension = iinfo.dimension();
    // On ne traite que les entités de la dimension du maillage.
    if (item_dimension != (mesh_dimension - 1))
      continue;
    ItemTypeInfo* iti = itm->typeFromId(iinfo.arcaneType());
    info() << "Lecture des faces géotype=" << geotype << " arcane_type=" << iinfo.arcaneType()
           << " " << iti->typeName();
    // Pour l'instant, on ne sait pas lire les faces qui sont des polygones
    const bool is_polygon = (iinfo.medType() == MED_POLYGON);
 
    Int32 nb_item = _readItems(mesh, fid, meshname, iinfo, poly_nb_nodes, poly_types_id, med_connectivity, med_family_values);
    if (nb_item == 0)
      continue;
 
    ItemTypeId arcane_type(iinfo.arcaneType());
    Int32 nb_item_node = iinfo.nbNode();
    Int32 nb_family_values = med_family_values.size();
    if (arcane_type == IT_NullType) {
      // Indique un type pris en charge par MED mais pas par Arcane
      ARCANE_FATAL("Le type MED '{0}' n'est pas pris en charge par Arcane", iinfo.medType());
    }
 
    SmallArray<Int64> orig_nodes_id(nb_item_node);
    info() << "FACES_INFOS nb_item=" << nb_item << " type=" << arcane_type
           << " nb_family_values=" << nb_family_values << " connectivity_size=" << med_connectivity.size();
 
    const Int32* indirection = iinfo.indirection();
    Int64 med_connectivity_index = 0;
 
    for (Int32 i = 0; i < nb_item; ++i) {
      ArrayView<Int64> cinfo_span(orig_nodes_id);
      if (is_polygon) {
        // Chaque polygone a son propre nombre de noeuds, il faut donc
        // redimensionner le tableau de travail.
        nb_item_node = poly_nb_nodes[i];
        orig_nodes_id.resize(nb_item_node);
        cinfo_span = orig_nodes_id;
        arcane_type = ItemTypeId(poly_types_id[i]);
      }
      Span<med_int> med_cinfo_span(med_connectivity.span().subspan(med_connectivity_index, nb_item_node));
      if (indirection) {
        for (Integer k = 0; k < nb_item_node; ++k) {
          cinfo_span[k] = med_cinfo_span[indirection[k]];
        }
      }
      else {
        for (Integer k = 0; k < nb_item_node; ++k)
          cinfo_span[k] = med_cinfo_span[k];
      }
      //info() << "HANDLE_FACE nb_item=" << nb_item_node;
      med_connectivity_index += nb_item_node;
      // Recherche la face dans le maillage à partir des uniqueId() triés de ses noeuds
      nodes_reorderer.reorder(arcane_type, cinfo_span);
      ConstArrayView<Int64> ordered_nodes = nodes_reorderer.sortedNodes();
      //info() << "OrigMedNodes=" << med_cinfo_span;
      //info() << "OrigNodes=" << orig_nodes_id;
      //info() << "Nodes=" << ordered_nodes;
      Node first_node(MeshUtils::findOneItem(node_family, ordered_nodes[0]));
      if (first_node.null())
        ARCANE_FATAL("Impossible de trouver le nœud uid={0} pour l'indice de face '{1}'", ordered_nodes[0], i);
      Face face = MeshUtils::getFaceFromNodesUniqueId(first_node, ordered_nodes);
      if (face.null()) {
        info() << "ERREUR: Impossible de trouver la face dans le maillage i=" << i << " nœuds=" << ordered_nodes;
        info() << "Liste des faces pour le nœud=" << ItemPrinter(first_node);
        for (Face subface : first_node.faces()) {
          info() << "Face=" << ItemPrinter(subface);
          for (Node subnode : subface.nodes()) {
            info() << "  Nœud=" << ItemPrinter(subnode);
          }
        }
        ARCANE_FATAL("Impossible de trouver la face avec les nœuds=", ordered_nodes);
      }
      //info() << "Face=" << ItemPrinter(face);
 
      // Ajoute la face dans les groupes correspondants
      if (i < nb_family_values) {
        // Il y a une famille associée à l'entité
        med_int f = med_family_values[i];
        auto x = m_med_families_map.find(f);
        if (x == m_med_families_map.end()) {
          ARCANE_FATAL("Impossible de trouver l'ID de famille '{0}' pour la face '{1}' de géotype '{2}'",
                       f, i, iinfo.medType());
        }
        //info() << "Ajout de la face au groupe_index=" << x->second.m_index;
        m_med_groups[x->second.m_index].m_local_ids.add(face.localId());
      }
    }
    info() << "FIN_LECTURE_DES_ENTITES";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshReader::eReturnType MEDMeshReader::
_readNodesCoordinates(IPrimaryMesh* mesh, Int64 nb_node, Int32 spacedim,
                      med_idt fid, const char* meshname)
{
  const bool do_verbose = false;
  // Lit les coordonnées des noeuds et positionne les coordonnées dans Arcane
 
  // La connectivité dans MED commence à 1 et Arcane à 0.
  // Le premier noeud a donc un pour uniqueId() la valeur
  UniqueArray<Real3> nodes_coordinates(nb_node + 1);
  {
    UniqueArray<med_float> coordinates(nb_node * spacedim);
    int err = MEDmeshNodeCoordinateRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
                                      coordinates.data());
    if (err < 0) {
      error() << "Impossible de lire les coordonnées des nœuds err=" << err;
      return IMeshReader::RTError;
    }
 
    if (spacedim == 3) {
      for (Int64 i = 0; i < nb_node; ++i) {
        Real3 xyz(coordinates[i * 3], coordinates[(i * 3) + 1], coordinates[(i * 3) + 2]);
        if (do_verbose)
          info() << "I=" << i << " XYZ=" << xyz;
        nodes_coordinates[i + 1] = xyz;
      }
    }
    else if (spacedim == 2) {
      for (Int64 i = 0; i < nb_node; ++i) {
        Real3 xyz(coordinates[i * 2], coordinates[(i * 2) + 1], 0.0);
        if (do_verbose)
          info() << "I=" << i << " XYZ=" << xyz;
        nodes_coordinates[i + 1] = xyz;
      }
    }
    else
      ARCANE_THROW(NotImplementedException, "spacedim!=2 && spacedim!=3");
  }
 
  // Positionne les coordonnées
  {
    VariableNodeReal3& nodes_coord_var(mesh->nodesCoordinates());
    ENUMERATE_NODE (inode, mesh->allNodes()) {
      Node node = *inode;
      nodes_coord_var[inode] = nodes_coordinates[node.uniqueId()];
    }
  }
  return IMeshReader::RTOk;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
Int32 MEDMeshReader::
_readItems(IPrimaryMesh* mesh, med_idt fid, const char* meshname,
           const MEDToArcaneItemInfo& iinfo,
           Array<Int16>& poly_nb_nodes,
           Array<Int16>& poly_types_id,
           Array<med_int>& connectivity,
           Array<med_int>& family_values)
{
  constexpr bool is_verbose = false;
 
  connectivity.clear();
  family_values.clear();
 
  ItemTypeMng* itm = mesh->itemTypeMng();
  int med_item_type = iinfo.medType();
  med_bool coordinatechangement = {};
  med_bool geotransformation = {};
  med_int nb_med_item = 0;
  if (iinfo.medType() == MED_POLYHEDRON) {
    nb_med_item = _readPolyhedrons(mesh, fid, meshname, poly_nb_nodes, poly_types_id, connectivity);
  }
  else if (iinfo.medType() == MED_POLYGON) {
    // Pour les polygones, il faut un appel spécifique pour le nombre d'index.
    // Ce nombre correspond au nombre d'entités plus un.
    med_int nb_index = ::MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, med_item_type,
                                        MED_INDEX_NODE, MED_NODAL, &coordinatechangement,
                                        &geotransformation);
    if (nb_index < 0)
      ARCANE_FATAL("Impossible de lire le med_item_type MED '{0}' erreur={1}", med_item_type, nb_index);
 
    info() << "MED: Lecture des entités";
    info() << "MED: type=" << med_item_type << " nb_index=" << nb_index;
    if (nb_index < 1)
      return 0;
    nb_med_item = nb_index - 1;
    poly_nb_nodes.resize(nb_med_item);
    poly_types_id.resize(nb_med_item);
    // Combien de nœuds pour la connectivité du polygone ?
    med_int nb_connectivity = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT,
                                             MED_CELL, MED_POLYGON, MED_CONNECTIVITY, MED_NODAL,
                                             &coordinatechangement, &geotransformation);
    if (nb_connectivity < 0)
      ARCANE_FATAL("Impossible d'obtenir la taille de connectivité pour MED_POLYGON err={0}", nb_connectivity);
 
    // La table \a indexes contient pour chaque maille l'indice de son premier
    // noeud dans la connectivité. Le nombre de noeuds de la i-ème entité
    // est donc égal à (indexes[i+1]-indexes[i]).
    UniqueArray<med_int> indexes(nb_index);
    connectivity.resize(nb_connectivity);
    info() << "Lecture des polygones nb_connectivity=" << nb_connectivity;
    int r = MEDmeshPolygonRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, MED_NODAL,
                             indexes.data(), connectivity.data());
    if (r < 0)
      ARCANE_FATAL("Impossible de lire la connectivité pour MED_POLYGON err={0}", r);
    info() << "INDEXES=" << indexes;
    for (Int32 i = 0; i < nb_med_item; ++i) {
      Int16 nb_node_for_cell = CheckedConvert::toInt16(indexes[i + 1] - indexes[i]);
      poly_nb_nodes[i] = nb_node_for_cell;
      poly_types_id[i] = itm->getPolygonType(static_cast<Int16>(nb_node_for_cell));
    }
  }
  else {
    nb_med_item = ::MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, med_item_type,
                                   MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
                                   &geotransformation);
    if (nb_med_item < 0)
      ARCANE_FATAL("Impossible de lire le med_item_type MED '{0}' erreur={1}", med_item_type, nb_med_item);
 
    info() << "MED: Lecture des entités";
    info() << "MED: type=" << med_item_type << " nb_item=" << nb_med_item;
    if (nb_med_item == 0)
      return 0;
 
    Int64 nb_node = iinfo.nbNode();
    if (nb_node == 0)
      // Indique un élément que nous ne savons pas comment traiter.
      ARCANE_THROW(NotImplementedException, "Lecture des entités avec le type MED '{0}'", med_item_type);
 
    connectivity.resize(nb_node * nb_med_item);
    int err = MEDmeshElementConnectivityRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,
                                           med_item_type, MED_NODAL, MED_FULL_INTERLACE,
                                           connectivity.data());
    if (err < 0)
      ARCANE_FATAL("Impossible de lire la connectivité MED med_item_type '{0}' erreur={1}",
                   med_item_type, err);
  }
  if (is_verbose)
    info() << "CON: " << connectivity;
  {
    med_int nb_med_family = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT,
                                           MED_CELL, med_item_type, MED_FAMILY_NUMBER, MED_NODAL,
                                           &coordinatechangement, &geotransformation);
    info() << "nb_family=" << nb_med_family;
    if (nb_med_family < 0)
      ARCANE_FATAL("Impossible de lire la taille de la famille pour le type med_item_type={0} erreur={1}", med_item_type, nb_med_family);
    if (nb_med_family > 0) {
      family_values.resize(nb_med_family);
      int r = MEDmeshEntityFamilyNumberRd(fid, meshname, MED_NO_DT, MED_NO_IT,
                                          MED_CELL, med_item_type, family_values.data());
      if (r < 0)
        ARCANE_FATAL("Impossible de lire les valeurs de famille pour le type med_item_type={0} erreur={1}", med_item_type, nb_med_family);
      if (is_verbose)
        info() << "FAM: " << family_values;
    }
  }
  return nb_med_item;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
med_int MEDMeshReader::
_readPolyhedrons(IPrimaryMesh* mesh, med_idt fid, const char* meshname,
                 Array<Int16>& poly_nb_nodes,
                 Array<Int16>& poly_types_id,
                 Array<med_int>& connectivity)
{
  if (mesh->parallelMng()->commSize() > 1)
    ARCANE_FATAL("Les maillages MED polyédriques ne sont pas supportés en parallèle");
  const bool is_verbose = false;
  ItemTypeMngInternal* itmi = mesh->itemTypeMng()->_internalApi();
  med_bool coordinatechangement = {};
  med_bool geotransformation = {};
  const med_int med_item_type = MED_POLYHEDRON;
  info() << "MED: Lecture des entités polyédriques";
  // Pour les polyèdres, il faut un appel spécifique pour le nombre de faces
  // et la connectivité des noeuds
  med_int nb_face_index = ::MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, med_item_type,
                                           MED_INDEX_FACE, MED_NODAL, &coordinatechangement,
                                           &geotransformation);
  if (nb_face_index < 0)
    ARCANE_FATAL("Impossible de lire MED_INDEX_FACE pour le type Polyèdre erreur={0}", nb_face_index);
  info() << "MED: type=" << med_item_type << " nb_face_index=" << nb_face_index;
  if (nb_face_index < 1)
    return 0;
 
  med_int nb_node_index = ::MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, med_item_type,
                                           MED_INDEX_NODE, MED_NODAL, &coordinatechangement,
                                           &geotransformation);
  if (nb_node_index < 0)
    ARCANE_FATAL("Impossible de lire MED_INDEX_NODE pour le type Polyèdre erreur={0}", nb_node_index);
 
  info() << "MED: type=" << med_item_type << " nb_face_index=" << nb_face_index << " nb_node_index=" << nb_node_index;
  med_int nb_med_item = nb_face_index - 1;
  poly_nb_nodes.resize(nb_med_item);
  poly_types_id.resize(nb_med_item);
  // Combien de nœuds pour la connectivité du polygone ?
  med_int nb_connectivity = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT,
                                           MED_CELL, MED_POLYHEDRON, MED_CONNECTIVITY, MED_NODAL,
                                           &coordinatechangement, &geotransformation);
  if (nb_connectivity < 0)
    ARCANE_FATAL("Impossible d'obtenir la taille de connectivité pour MED_POLYHEDRON err={0}", nb_connectivity);
 
  // La table \a face_indexes contient pour chaque maille l'indice de sa première
  // face dans la connectivité. Le nombre de faces de la i-ème entité
  // est donc égal à (face_indexes[i+1] - face_indexes[i]).
  UniqueArray<med_int> face_indexes(nb_face_index);
  UniqueArray<med_int> node_indexes(nb_node_index);
  connectivity.clear();
  connectivity.reserve(nb_connectivity);
  UniqueArray<med_int> med_connectivity(nb_connectivity);
  info() << "Lecture des polyèdres nb_connectivity=" << nb_connectivity;
  int r = MEDmeshPolyhedronRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, MED_NODAL,
                              face_indexes.data(), node_indexes.data(), med_connectivity.data());
  if (r < 0)
    ARCANE_FATAL("Impossible de lire la connectivité pour MED_POLYGON err={0}", r);
  if (is_verbose) {
    info() << "FACE_INDEXES=" << face_indexes;
    info() << "NODE_INDEXES=" << node_indexes;
    info() << "CONNECTIVITY=" << med_connectivity;
  }
  UniqueArray<Int16> local_nodes_of_cell;
  UniqueArray<Int32> nodes_of_cell;
  UniqueArray<Int32> nodes_of_face;
 
  // Informations pour créer le type Arcane correspondant
  UniqueArray<Int16> arcane_faces_nb_node;
  UniqueArray<Int16> arcane_faces_nodes;
  // Indice local dans la maille des noeuds ;
  std::map<Int32, Int16> connectivity_to_local_index;
  for (Int32 z = 0; z < nb_med_item; ++z) {
    Int16 nb_local_node = 0;
    nodes_of_cell.clear();
    connectivity_to_local_index.clear();
    local_nodes_of_cell.clear();
    arcane_faces_nb_node.clear();
    arcane_faces_nodes.clear();
    Int32 connectivity_index = connectivity.size();
    // La numérotation commence à 1, il faut donc retirer 1 à face_indexes et node_indexes
    Int32 first_face_index = face_indexes[z] - 1;
    Int32 next_face_index = face_indexes[z + 1] - 1;
    Int32 cell_nb_face = next_face_index - first_face_index;
    Int32 cell_nb_node = node_indexes[next_face_index] - node_indexes[first_face_index];
    if (is_verbose)
      info() << "POLYHEDRAL_CELL=" << z << " nb_face=" << cell_nb_face
             << " nb_node=" << cell_nb_node << " first_face_index=" << first_face_index
             << " nb_info_in_connectivity=" << node_indexes[cell_nb_face];
    Int16 nb_connectivity_for_cell = 3 + cell_nb_node + cell_nb_face;
    connectivity.add(nb_connectivity_for_cell);
    const Int64 scheme_version = 1;
    connectivity.add(scheme_version);
    connectivity.add(cell_nb_face);
    for (Int32 k = 0; k < cell_nb_face; ++k) {
      Int32 first_node_index = node_indexes[first_face_index + k] - 1;
      Int32 next_node_index = node_indexes[first_face_index + k + 1] - 1;
      Int16 face_nb_node = CheckedConvert::toInt16(next_node_index - first_node_index);
      nodes_of_face.resize(face_nb_node);
      arcane_faces_nb_node.add(face_nb_node);
      connectivity.add(face_nb_node);
      for (Int32 p = 0; p < face_nb_node; ++p) {
        // TODO: vérifier si (-1) est nécessaire
        Int32 node_id = med_connectivity[first_node_index + p];
        auto x = connectivity_to_local_index.find(node_id);
        Int16 local_node_index = -1;
        if (x == connectivity_to_local_index.end()) {
          local_node_index = nb_local_node;
          connectivity_to_local_index[node_id] = nb_local_node;
          ++nb_local_node;
          local_nodes_of_cell.add(local_node_index);
          nodes_of_cell.add(node_id);
        }
        else
          local_node_index = x->second;
        connectivity.add(node_id);
        nodes_of_face[p] = local_node_index;
        arcane_faces_nodes.add(local_node_index);
      }
      if (is_verbose)
        info() << "  POLYHEDRAL_FACE=" << k << " nb_node=" << face_nb_node << " nodes=" << nodes_of_face.view();
      //Int32 face_nb_node = face_indexes[z+1] - face_indexes[z];
    }
    if (is_verbose) {
      info() << "POLYHEDRAL_CELL=" << z << " nb_local_node=" << nodes_of_cell.size() << " nodes=" << nodes_of_cell
             << " nb_connectivity_for_cell=" << nb_connectivity_for_cell;
      info() << "POLYHEDRAL_CELL=" << z << " arcane_faces_nb_node=" << arcane_faces_nb_node << " nodes=" << arcane_faces_nodes;
    }
    poly_types_id[z] = IT_GenericPolyhedron;
    poly_nb_nodes[z] = nb_connectivity_for_cell;
  }
  return nb_med_item;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MEDMeshReader::
_readFamilies(med_idt fid, const char* meshname)
{
  FixedArray<char, MED_NAME_SIZE + 1> familyname;
 
  info() << "Lecture des familles";
 
  // Récupère le nombre de familles
  med_int nb_family = MEDnFamily(fid, meshname);
  if (nb_family < 0)
    ARCANE_FATAL("Impossible de lire le nombre de familles (erreur={0})", nb_family);
 
  info() << "MED: nb_family= " << nb_family;
  for (med_int i = 0; i < nb_family; i++) {
    info() << "MED: Lecture de la famille i=" << i;
 
    med_int nb_group = MEDnFamilyGroup(fid, meshname, i + 1);
    if (nb_group < 0)
      ARCANE_FATAL("Impossible de lire le nombre de groupes pour l'indice de famille={0}", i);
    info() << "MED: indice de famille=" << i << " nb_group=" << nb_group;
 
    // Lit les groupes de la famille
    // Même s'il n'y a pas de groupes associés à la famille on continue
    // le traitement car les entités peuvent référencer des familles sans groupe.
 
    // Dans MED, les groupes ont une taille fixe maximale MED_LNAME_SIZE
    UniqueArray<char> all_group_names(MED_LNAME_SIZE * nb_group + 1);
    med_int family_number = 0;
    if (MEDfamilyInfo(fid, meshname, i + 1, familyname.data(), &family_number, all_group_names.data()) < 0)
      ARCANE_FATAL("Impossible de lire les noms de groupes à partir de l'indice de famille={0}", i);
 
    MEDFamilyInfo med_family(family_number);
    Int32 group_index = m_med_groups.size();
    med_family.m_index = group_index;
    MEDGroupInfo med_group(group_index);
 
    // Récupère les noms des groupes de la famille
    for (Int32 z = 0; z < nb_group; ++z) {
      //info() << " groupname=" << group_names << " number=" << familynumber;
      SmallSpan<char> med_group_name = all_group_names.smallSpan().subSpan(MED_LNAME_SIZE * z, MED_LNAME_SIZE);
      // Les groupes dans MED peuvent contenir des caractères non supportés par Arcane.
      // On les enlève.
      SmallArray<Byte, MED_LNAME_SIZE + 1> valid_name;
      Int32 pos = 0;
      for (; pos < MED_LNAME_SIZE; ++pos) {
        char c = med_group_name[pos];
        if (c == '\0')
          break;
        if (c == ' ' || c == '_')
          continue;
        valid_name.add(static_cast<Byte>(c));
      }
      String name(valid_name.view());
      med_group.m_names.add(name);
      info() << "ID de famille=" << family_number << " groupe='" << name << "'";
    }
 
    m_med_families_map.insert(std::make_pair(family_number, med_family));
    m_med_groups.add(med_group);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void MEDMeshReader::
_broadcastGroups(ConstArrayView<String> group_names, IItemFamily* family)
{
  IParallelMng* pm = m_mesh->parallelMng();
 
  Int32 rank = pm->commRank();
  // S'assure que tous les rangs connaissent les groupes
  if (rank == 0) {
    Int32 nb_group = group_names.size();
    pm->broadcast(ArrayView<Int32>(1, &nb_group), 0);
    for (String name : group_names)
      pm->broadcastString(name, 0);
  }
  else {
    Int32 nb_group = 0;
    pm->broadcast(ArrayView<Int32>(1, &nb_group), 0);
    String current_group_name;
    for (Int32 i = 0; i < nb_group; ++i) {
      pm->broadcastString(current_group_name, 0);
      CellGroup cell_group = family->findGroup(current_group_name, true);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class MEDMeshReaderService
: public BasicService
, public IMeshReader
{
 public:
 
  explicit MEDMeshReaderService(const ServiceBuildInfo& sbi)
  : BasicService(sbi)
  {}
 
 public:
 
  void build() override {}
  bool allowExtension(const String& str) override
  {
    return str == "med";
  }
  eReturnType readMeshFromFile(IPrimaryMesh* mesh,
                               [[maybe_unused]] const XmlNode& mesh_element,
                               const String& file_name,
                               const String& dir_name,
                               [[maybe_unused]] bool use_internal_partition) override
  {
    ARCANE_UNUSED(dir_name);
    MEDMeshReader reader(traceMng());
    return reader.readMesh(mesh, file_name);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE(MEDMeshReaderService,
                        ServiceProperty("MEDMeshReader", ST_SubDomain),
                        ARCANE_SERVICE_INTERFACE(IMeshReader));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class MEDCaseMeshReader
: public AbstractService
, public ICaseMeshReader
{
 public:
 
  class Builder
  : public IMeshBuilder
  {
   public:
 
    explicit Builder(ITraceMng* tm, const CaseMeshReaderReadInfo& read_info)
    : m_trace_mng(tm)
    , m_read_info(read_info)
    {}
 
   public:
 
    void fillMeshBuildInfo(MeshBuildInfo& build_info) override
    {
      ARCANE_UNUSED(build_info);
    }
    void allocateMeshItems(IPrimaryMesh* pm) override
    {
      MEDMeshReader reader(m_trace_mng);
      String fname = m_read_info.fileName();
      m_trace_mng->info() << "Lecteur MED (ICaseMeshReader) file_name=" << fname;
      IMeshReader::eReturnType ret = reader.readMesh(pm, fname);
      if (ret != IMeshReader::RTOk)
        ARCANE_FATAL("Impossible de lire le fichier MED");
    }
 
   private:
 
    ITraceMng* m_trace_mng;
    CaseMeshReaderReadInfo m_read_info;
  };
 
 public:
 
  explicit MEDCaseMeshReader(const ServiceBuildInfo& sbi)
  : AbstractService(sbi)
  {}
 
 public:
 
  Ref<IMeshBuilder> createBuilder(const CaseMeshReaderReadInfo& read_info) const override
  {
    IMeshBuilder* builder = nullptr;
    if (read_info.format() == "med")
      builder = new Builder(traceMng(), read_info);
    return makeRef(builder);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE(MEDCaseMeshReader,
                        ServiceProperty("MEDCaseMeshReader", ST_SubDomain),
                        ARCANE_SERVICE_INTERFACE(ICaseMeshReader));
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/