VoronoiMeshIOService.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VoronoiMeshIOService.cc                                     (C) 2000-2009 */
/*                                                                           */
/* Reading/Writing a Voronoi mesh. Provisional format.                       */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
 
#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/ITraceMng.h"
#include "arcane/utils/String.h"
#include "arcane/utils/IOException.h"
#include "arcane/utils/Collection.h"
#include "arcane/utils/Enumerator.h"
 
#include "arcane/utils/Real3.h"
 
#include "arcane/core/FactoryService.h"
#include "arcane/core/IMeshReader.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/IMeshSubMeshTransition.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/Item.h"
#include "arcane/core/ItemEnumerator.h"
#include "arcane/core/VariableTypes.h"
#include "arcane/core/IVariableAccessor.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IIOMng.h"
#include "arcane/core/IMeshUtilities.h"
#include "arcane/core/IMeshWriter.h"
#include "arcane/core/BasicService.h"
#include "arcane/core/XmlNode.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class VoronoiFile;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class VoronoiMeshIOService
: public BasicService
, public IMeshReader
{
 public:
 
  VoronoiMeshIOService(const ServiceBuildInfo& sbi);
 
  ~VoronoiMeshIOService();
 
 public:
 
  virtual void build() {}
 
 public:
 
  virtual bool allowExtension(const String& str)
  {
    return str == "vor";
  }
 
 public:
 
  virtual eReturnType readMeshFromFile(IPrimaryMesh* mesh, const XmlNode& mesh_node, const String& file_name,
                                       const String& dir_name, bool use_internal_partition);
 
  virtual bool hasCutInfos() const { return false; }
  virtual ConstArrayView<Integer> communicatingSubDomains() const { return ConstArrayView<Integer>(); }
 
 private:
 
  bool _readMesh(IPrimaryMesh* mesh, const String& file_name, const String& dir_name, bool use_internal_partition);
  bool _readHybridGrid(IPrimaryMesh* mesh, VoronoiFile& voronoi_file, bool use_internal_partition);
  void _readCellVariable(IMesh* mesh, VoronoiFile& voronoi_file, const String& name_str, Integer nb_cell);
  void _readItemGroup(IMesh* mesh, VoronoiFile& voronoi_file, const String& name_str, Integer nb_item,
                      eItemKind ik, ConstArrayView<Integer> local_ids);
  void _createFaceGroup(IMesh* mesh, const String& name, ConstArrayView<Integer> faces_lid);
  bool _readData(IMesh* mesh, VoronoiFile& voronoi_file, bool use_internal_partition, eItemKind cell_kind,
                 ConstArrayView<Integer> local_ids);
  void _readNodesHybridGrid(IMesh* mesh, VoronoiFile& voronoi_file, Array<Real3>& node_coords);
  void _readCellsHybridGrid(IMesh* mesh, VoronoiFile& voronoi_file,
                            Array<Integer>& cells_nb_node,
                            Array<Integer>& cells_type,
                            Array<Int64>& cells_connectivity,
                            Integer& mesh_dimension);
  void _readFacesMesh(IMesh* mesh, const String& file_name,
                      const String& dir_name, bool use_internal_partition);
 
 private:

  UniqueArray<VariableCellReal3*> m_variables;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class VoronoiFile
{
 public:
 
  static const int BUFSIZE = 10000;
 
 public:
 
  VoronoiFile(std::istream* stream)
  : m_stream(stream)
  {}
  const char* getNextLine();
  Real getReal();
  Integer getInteger();
  bool isEnd()
  {
    (*m_stream) >> ws;
    return m_stream->eof();
  }
 
 private:
 
  std::istream* m_stream;
  char m_buf[BUFSIZE];
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
const char* VoronoiFile::
getNextLine()
{
  while (m_stream->good()) {
    m_stream->getline(m_buf, sizeof(m_buf) - 1);
    if (m_stream->eof())
      break;
    bool is_comment = true;
    if (m_buf[0] == '\n' || m_buf[0] == '\r')
      continue;
    // Regarde si un caractère de commentaire est présent
    for (int i = 0; i < BUFSIZE && m_buf[i] != '\0'; ++i) {
      if (!isspace(m_buf[i])) {
        is_comment = (m_buf[i] == '#');
        break;
      }
    }
    if (!is_comment) {
 
      // Supprime le '\n' ou '\r' final
      for (int i = 0; i < BUFSIZE && m_buf[i] != '\0'; ++i) {
        //cout << " V=" << m_buf[i] << " I=" << (int)m_buf[i] << "\n";
        if (m_buf[i] == '\n' || m_buf[i] == '\r') {
          m_buf[i] = '\0';
          break;
        }
      }
      return m_buf;
    }
  }
  throw IOException("VoronoiFile::getNexLine()", "Unexpected EndOfFile");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real VoronoiFile::
getReal()
{
  Real v = 0.;
  (*m_stream) >> ws >> v;
  if (m_stream->good())
    return v;
  throw IOException("VoronoiFile::getReal()", "Bad Real");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer VoronoiFile::
getInteger()
{
  Integer v = 0;
  (*m_stream) >> ws >> v;
  if (m_stream->good())
    return v;
  throw IOException("VoronoiFile::getInteger()", "Bad Integer");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SUB_DOMAIN_FACTORY(VoronoiMeshIOService, IMeshReader, VoronoiMeshIO);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
VoronoiMeshIOService::
VoronoiMeshIOService(const ServiceBuildInfo& sbi)
: BasicService(sbi)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
VoronoiMeshIOService::
~VoronoiMeshIOService()
{
  const Integer size = m_variables.size();
  for (Integer i = 0; i < size; ++i) {
    delete m_variables[i];
    m_variables[i] = NULL;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

IMeshReader::eReturnType VoronoiMeshIOService::
readMeshFromFile(IPrimaryMesh* mesh, const XmlNode& mesh_node,
                 const String& filename, const String& dir_name,
                 bool use_internal_partition)
{
  ARCANE_UNUSED(mesh_node);
  ARCANE_UNUSED(use_internal_partition);
 
  bool ret = _readMesh(mesh, filename, dir_name, use_internal_partition);
  if (ret)
    return RTError;
 
  return RTOk;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool VoronoiMeshIOService::
_readMesh(IPrimaryMesh* mesh, const String& file_name, const String& dir_name,
          bool use_internal_partition)
{
  ARCANE_UNUSED(dir_name);
 
  std::ifstream ifile(file_name.localstr());
  if (!ifile) {
    error() << "Unable to read file '" << file_name << "'";
    return true;
  }
  VoronoiFile voronoi_file(&ifile);
 
  // Lecture du type de maillage
  // TODO: en parallèle, avec use_internal_partition vrai, seul le processeur 0
  // lit les données. Dans ce cas, inutile que les autres ouvre le fichier.
 
  bool ret = true;
  ret = _readHybridGrid(mesh, voronoi_file, use_internal_partition);
  return ret;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void VoronoiMeshIOService::
_readNodesHybridGrid(IMesh* mesh, VoronoiFile& voronoi_file, Array<Real3>& node_coords)
{
  ARCANE_UNUSED(mesh);
 
  const char* func_name = "VoronoiMeshIOService::_readNodesHybridGrid()";
  const char* buf = voronoi_file.getNextLine();
  std::istringstream iline(buf);
  std::string points_str;
  std::string data_type_str;
  Integer nb_node = 0;
  iline >> ws >> nb_node;
  if (!iline)
    throw IOException(func_name, "Syntax error while reading number of nodes");
  if (nb_node < 0) {
    String msg = String("Invalid number of nodes: n=") + nb_node;
    throw IOException(func_name, msg);
  }
 
  info() << " Info: " << nb_node;
 
  // Reading coordinates
  node_coords.resize(nb_node);
  {
    for (Integer i = 0; i < nb_node; ++i) {
      Real nx = voronoi_file.getReal();
      Real ny = voronoi_file.getReal();
      Real nz = voronoi_file.getReal();
      node_coords[i] = Real3(nx, ny, nz);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void VoronoiMeshIOService::
_readCellsHybridGrid(IMesh* mesh, VoronoiFile& voronoi_file,
                     Array<Integer>& cells_nb_node,
                     Array<Integer>& cells_type,
                     Array<Int64>& cells_connectivity,
                     Integer& mesh_dimension)
{
  ARCANE_UNUSED(mesh);
 
  const char* func_name = "VoronoiMeshIOService::_readCellsHybridGrid()";
  const char* buf = voronoi_file.getNextLine();
  std::istringstream iline(buf);
  std::string cells_str;
  Integer nb_cell = 0;
  Integer nb_cell_node = 0;
  iline >> ws >> nb_cell >> ws >> nb_cell_node;
  if (!iline)
    throw IOException(func_name, "Syntax error while reading cells");
  if (nb_cell < 0 || nb_cell_node < 0) {
    throw IOException(func_name, String::format("Invalid dimensions: nb_cell={0} nb_cell_node={1}", nb_cell, nb_cell_node));
  }
 
  ItemTypeMng* item_type_mng = mesh->itemTypeMng();
 
  mesh_dimension = 3; // will be set to two if for all types, nb_edges == nb_faces
  bool is_mesh_2d = true;
 
  cells_nb_node.resize(nb_cell);
  cells_type.resize(nb_cell);
  cells_connectivity.resize(nb_cell_node);
  {
    Integer connectivity_index = 0;
    for (Integer i = 0; i < nb_cell; ++i) {
      const Integer user_cell_type = voronoi_file.getInteger();
      const Integer internal_cell_type = user_cell_type + ItemTypeMng::nbBuiltInItemType();
      cells_type[i] = internal_cell_type;
      if (user_cell_type < 0 || internal_cell_type >= ItemTypeMng::nbBasicItemType())
        fatal() << "Bad item type " << user_cell_type;
      /* const Integer n_check = */ voronoi_file.getInteger();
      ItemTypeInfo* item_type = item_type_mng->typeFromId(internal_cell_type);
      is_mesh_2d = is_mesh_2d && (item_type->nbLocalEdge() == item_type->nbLocalFace());
      // optimizable with a local cache
      const Integer n = item_type->nbLocalNode();
      cells_nb_node[i] = n;
      for (Integer j = 0; j < n; ++j) {
        const Integer node_id = voronoi_file.getInteger();
        cells_connectivity[connectivity_index] = node_id;
        ++connectivity_index;
      }
    }
  }
  if (is_mesh_2d)
    mesh_dimension = 2;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool VoronoiMeshIOService::
_readHybridGrid(IPrimaryMesh* mesh, VoronoiFile& voronoi_file, bool use_internal_partition)
{
  // const char* func_name = "VoronoiMeshIOService::_readUnstructuredGrid()";
  //IParallelMng* pm = subDomain()->parallelMng();
  Integer nb_cell = 0;
  Integer nb_cell_node = 0;
  Integer sid = subDomain()->subDomainId();
  UniqueArray<Real3> node_coords;
  UniqueArray<Int64> cells_infos;
  UniqueArray<Integer> cells_local_id;
  UniqueArray<Integer> faces_local_id;
  // If we use the internal partitioner, only the subdomain reads the mesh
  bool need_read = true;
  Integer mesh_dimension(-1);
  if (use_internal_partition)
    need_read = (sid == 0);
 
  if (need_read) {
    _readNodesHybridGrid(mesh, voronoi_file, node_coords);
    //nb_node = node_coords.size();
 
    // Reading cell info
    // Reading connectivity
    UniqueArray<Integer> cells_nb_node;
    UniqueArray<Int64> cells_connectivity;
    UniqueArray<Integer> cells_type;
    _readCellsHybridGrid(mesh, voronoi_file, cells_nb_node, cells_type, cells_connectivity, mesh_dimension);
    nb_cell = cells_nb_node.size();
    nb_cell_node = cells_connectivity.size();
    cells_local_id.resize(nb_cell);
 
    // Cell creation
    // Info for cell creation
    // per cell: 1 for its unique id,
    //             1 for its type,
    //             1 for each node
    cells_infos.resize(nb_cell * 2 + nb_cell_node);
    {
      Integer cells_infos_index = 0;
      Integer connectivity_index = 0;
      for (Integer i = 0; i < nb_cell; ++i) {
        Integer current_cell_nb_node = cells_nb_node[i];
        Integer cell_unique_id = i;
 
        cells_local_id[i] = i;
 
        cells_infos[cells_infos_index] = cells_type[i];
        ++cells_infos_index;
 
        cells_infos[cells_infos_index] = cell_unique_id;
        ++cells_infos_index;
 
        for (Integer z = 0; z < current_cell_nb_node; ++z) {
          cells_infos[cells_infos_index + z] = cells_connectivity[connectivity_index + z];
        }
        cells_infos_index += current_cell_nb_node;
        connectivity_index += current_cell_nb_node;
      }
    }
  }
 
  Integer dimension = subDomain()->parallelMng()->reduce(Parallel::ReduceMax, mesh_dimension);
  mesh->setDimension(dimension);
  mesh->allocateCells(nb_cell, cells_infos, false);
  mesh->endAllocate();
 
  // Positions the coordinates
  {
    VariableNodeReal3& nodes_coord_var(mesh->nodesCoordinates());
    ENUMERATE_NODE (inode, mesh->allNodes()) {
      Node node = *inode;
      Int32 node_uid = node.uniqueId().asInt32();
      nodes_coord_var[inode] = node_coords[node_uid];
    }
  }
 
  // Now, check if there are data associated with the file
  bool r = _readData(mesh, voronoi_file, use_internal_partition, IK_Cell, cells_local_id);
  if (r)
    return r;
 
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool VoronoiMeshIOService::
_readData(IMesh* mesh, VoronoiFile& voronoi_file, bool use_internal_partition,
          eItemKind cell_kind, ConstArrayView<Integer> local_ids)
{
  ARCANE_UNUSED(use_internal_partition);
  ARCANE_UNUSED(local_ids);
 
  // Only the master subdomain reads the values. However, the other
  // subdomains must know the list of variables
  Integer sid = subDomain()->subDomainId();
  Integer nb_cell_kind = mesh->nbItem(cell_kind);
  if (sid == 0) {
    _readCellVariable(mesh, voronoi_file, "CellCenter", nb_cell_kind);
  }
  if (sid != 0) {
    VariableCellReal3* var = new VariableCellReal3(VariableBuildInfo(mesh, "CellCenter"));
    m_variables.add(var);
  }
 
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void VoronoiMeshIOService::
_readCellVariable(IMesh* mesh, VoronoiFile& voronoi_file, const String& var_name, Integer nb_cell)
{
  //TODO Perform the correct conversion from uniqueId() to localId()
  Real cx, cy, cz;
  info() << "Reading values for variable: " << var_name << " n=" << nb_cell;
  VariableCellReal3* var = new VariableCellReal3(VariableBuildInfo(mesh, var_name));
  m_variables.add(var);
  Real3ArrayView values(var->asArray());
  for (Integer i = 0; i < nb_cell; ++i) {
    cx = voronoi_file.getReal();
    cy = voronoi_file.getReal();
    cz = voronoi_file.getReal();
    values[i] = Real3(cx, cy, cz);
  }
  info() << "Variable build done: " << voronoi_file.isEnd();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void VoronoiMeshIOService::
_readItemGroup(IMesh* mesh, VoronoiFile& voronoi_file, const String& name, Integer nb_item,
               eItemKind ik, ConstArrayView<Integer> local_ids)
{
  IItemFamily* item_family = mesh->itemFamily(ik);
  info() << "Reading group info for group: " << name;
 
  IntegerUniqueArray ids;
  for (Integer i = 0; i < nb_item; ++i) {
    Integer v = voronoi_file.getInteger();
    if (v != 0)
      ids.add(local_ids[i]);
  }
  info() << "Building group: " << name << " nb_element=" << ids.size();
 
  item_family->createGroup(name, ids);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/