MeshSectionService.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshSectionService.cc                                       (C) 2000-2026 */
/*                                                                           */
/* Service permettant la création d'un maillage avec une section d'un        */
/* autre maillage.                                                           */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/IMesh.h"
#include "arcane/core/IMeshFactoryMng.h"
#include "arcane/core/IMeshMng.h"
#include "arcane/core/IMeshModifier.h"
#include "arcane/core/IPrimaryMesh.h"
#include "arcane/core/MeshBuildInfo.h"
 
#include "arcane/core/IMeshSection.h"
#include "arcane/std/MeshSection_axl.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class MeshSectionService
: public ArcaneMeshSectionObject
{
 public:
 
  explicit MeshSectionService(const ServiceBuildInfo& sbi)
  : ArcaneMeshSectionObject(sbi)
  , m_creation_type(sbi.creationType())
  {}
 
 public:
 
  void addPlane(const Real3& p0, const Real3& normal) override;
 
  void setVariables(VariableCollection variables) override;
  VariableCollection variables() override { return {}; }
  void setServiceMeshUniqueId(Int32 unique_id) override;
  void updateSection() override;
 
  MeshHandle meshSection() override
  {
    return m_cloned_mesh->handle();
  }
 
 private:
 
  void _createMesh();
  void _createCells(Int32& nb_cell, UniqueArray<Int64>& cells_infos, Int32& nb_face, UniqueArray<Int64>& faces_infos, std::unordered_map<Int64, Real3>& pos_node);
  void _compute();
 
 private:
 
  // VariableCollection m_variables_ori;
  IPrimaryMesh* m_cloned_mesh = nullptr;
  UniqueArray<std::pair<Real3, Real3>> m_plans;
  Int32 m_mesh_uid = -1;
  eServiceType m_creation_type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_REGISTER_SERVICE_MESHSECTION(MeshSection, MeshSectionService);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
addPlane(const Real3& p0, const Real3& normal)
{
  m_plans.add({ p0, math::normalizeReal3(normal) });
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
setVariables(VariableCollection variables)
{
  ARCANE_UNUSED(variables);
  ARCANE_NOT_YET_IMPLEMENTED("Not supported yet");
  // m_variables_ori = variables;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
setServiceMeshUniqueId(Int32 unique_id)
{
  m_mesh_uid = unique_id;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
updateSection()
{
  _createMesh();
  _compute();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
_createMesh()
{
  if (m_cloned_mesh != nullptr) {
    m_cloned_mesh->modifier()->clearItems();
  }
 
  IMeshMng* mm = subDomain()->meshMng();
 
  if (m_mesh_uid == -1) {
    if (m_creation_type == ST_CaseOption) {
      m_mesh_uid = options()->getUniqueIdServiceMesh();
    }
    else {
      m_mesh_uid = 0;
    }
  }
 
  String service_mesh_name = mesh()->name() + "_MeshSection" + m_mesh_uid;
 
  MeshHandle* mesh_handle = mm->findMeshHandle(service_mesh_name, false);
 
  if (mesh_handle == nullptr) {
    IParallelMng* pm = subDomain()->parallelMng();
    MeshBuildInfo mbi(service_mesh_name);
    mbi.addParallelMng(makeRef(pm));
    m_cloned_mesh = mm->meshFactoryMng()->createMesh(mbi);
    m_cloned_mesh->modifier()->setDynamic(true);
    m_cloned_mesh->setDimension(mesh()->dimension());
    m_cloned_mesh->endAllocate();
  }
  else {
    m_cloned_mesh = mesh_handle->mesh()->toPrimaryMesh();
    m_cloned_mesh->modifier()->clearItems();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
_createCells(Int32& sd_nb_cell, UniqueArray<Int64>& cells_infos, Int32& sd_nb_face, UniqueArray<Int64>& faces_infos, std::unordered_map<Int64, Real3>& pos_node)
{
  VariableNodeReal3& node_coord = mesh()->nodesCoordinates();
 
  VariableFaceBool is_added(VariableBuildInfo(mesh(), "IsAdded"));
  is_added.fill(false);
 
  ENUMERATE_ (Cell, icell, ownCells()) {
    {
      Real3 b{ 0 };
      for (Node node : icell->nodes()) {
        b += node_coord[node];
      }
      b /= icell->nbNode();
 
      bool in_plan = true;
      for (auto& [p0, normal] : m_plans) {
        const Real dist = math::dot({ b - p0 }, normal);
        if (dist < 0) {
          in_plan = false;
          break;
        }
      }
 
      if (!in_plan)
        continue;
    }
 
    Int16 cell_type = icell->itemTypeId();
    cells_infos.add(cell_type);
 
    Int64 cell_uid = icell->uniqueId().asInt64();
    cells_infos.add(cell_uid);
 
    for (Node node : icell->nodes()) {
      Int64 node_uid = node.uniqueId().asInt64();
      cells_infos.add(node_uid);
      pos_node[node.uniqueId()] = node_coord[node];
    }
    ++sd_nb_cell;
 
    for (Face face : icell->faces()) {
      if (is_added[face]) continue;
      is_added[face] = true;
 
      Int16 face_type = face.itemTypeId();
      faces_infos.add(face_type);
 
      Int64 face_uid = face.uniqueId().asInt64();
      faces_infos.add(face_uid);
 
      for (Node node : face.nodes()) {
        Int64 node_uid = node.uniqueId().asInt64();
        faces_infos.add(node_uid);
        pos_node[node.uniqueId()] = node_coord[node];
      }
      ++sd_nb_face;
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshSectionService::
_compute()
{
  UniqueArray<Int64> cells_infos;
  cells_infos.reserve(10000);
 
  UniqueArray<Int64> faces_infos;
  faces_infos.reserve(10000);
 
  std::unordered_map<Int64, Real3> coord_map;
 
  Int32 nb_cell = 0;
  Int32 nb_face = 0;
 
  _createCells(nb_cell, cells_infos, nb_face, faces_infos, coord_map);
 
  m_cloned_mesh->modifier()->addFaces(nb_face, faces_infos);
  m_cloned_mesh->modifier()->addCells(nb_cell, cells_infos);
  m_cloned_mesh->modifier()->endUpdate();
 
  {
    VariableNodeReal3& node_coords(m_cloned_mesh->nodesCoordinates());
    ENUMERATE_ (Node, inode, m_cloned_mesh->allNodes()) {
      node_coords[inode] = coord_map[inode->uniqueId()];
    }
  }
 
  info() << "New mesh -- NbNode : " << m_cloned_mesh->nbNode() << " -- NbCells : " << m_cloned_mesh->nbCell();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/