MeshMng.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshMng.cc                                                  (C) 2000-2023 */
/*                                                                           */
/* Class managing the list of meshes.                                        */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/impl/internal/MeshMng.h"
 
#include "arcane/utils/String.h"
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/IPrimaryMesh.h"
#include "arcane/core/MeshHandle.h"
#include "arcane/core/IVariableMng.h"
#include "arcane/core/internal/IVariableMngInternal.h"
 
#include "arcane/impl/internal/MeshFactoryMng.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshMng::
MeshMng(IApplication* app, IVariableMng* vm)
: TraceAccessor(vm->traceMng())
, m_variable_mng(vm)
, m_mesh_factory_mng(new MeshFactoryMng(app, this))
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshMng::
~MeshMng()
{
  delete m_mesh_factory_mng;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMng::
addMesh(IMesh* mesh)
{
  ARCANE_CHECK_POINTER(mesh);
  String name = mesh->name();
  info() << "Add mesh name=" << mesh->name() << " count=" << meshes().size();
  //std::cout << " ** ** ADD_MESH name=" << name << " this=" << mesh << '\n';
  // Checks if a handle for the mesh is already present.
  // If so, it uses it.
  MeshHandle* handle_ptr = findMeshHandle(name, false);
  if (handle_ptr) {
    // Checks that the handle does not already have an associated mesh or if it is
    // the same mesh that we already have
    // TODO: this should not be allowed anyway because the mesh
    // will be added multiple times to the list of meshes via
    // m_meshes.add().
    if (handle_ptr->hasMesh()) {
      IMesh* current_mesh = handle_ptr->mesh();
      //std::cout << " ** ** FOUND_HANDLE ref=" << handle_ptr->reference()
      //          << " old_mesh=" << current_mesh << " new_mesh=" << mesh << '\n';
      if (current_mesh != mesh)
        ARCANE_FATAL("MeshHandle '{0}' already have mesh", name);
    }
    else
      handle_ptr->_setMesh(mesh);
  }
  else {
    MeshHandle handle = _addMeshHandle(name);
    handle._setMesh(mesh);
  }
  _rebuildMeshList();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMesh* MeshMng::
getMesh(Integer index) const
{
  return m_meshes_handle[index].mesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IPrimaryMesh* MeshMng::
getPrimaryMesh(Integer index) const
{
  return getMesh(index)->toPrimaryMesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle* MeshMng::
findMeshHandle(const String& name, bool throw_exception)
{
  for (auto& handle : m_meshes_handle)
    if (handle.meshName() == name)
      return &handle;
  if (throw_exception)
    ARCANE_FATAL("no MeshHandle named '{0}' found", name);
  return nullptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle MeshMng::
findMeshHandle(const String& name)
{
  MeshHandle* handle = findMeshHandle(name, true);
  //std::cout << " ** ** FOUND_HANDLE name=" << name << " ptr=" << handle->reference()
  //          << " mesh=" << handle->mesh() << '\n';
  return MeshHandle(*handle);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle MeshMng::
createMeshHandle(const String& name)
{
  MeshHandle* old_handle = findMeshHandle(name, false);
  if (old_handle)
    ARCANE_FATAL("mesh handle already exists for name '{0}'", name);
  return _addMeshHandle(name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMesh* MeshMng::
findMesh(const String& name, bool throw_exception)
{
  const MeshHandle* handle = findMeshHandle(name, throw_exception);
  if (!handle)
    return nullptr;
  IMesh* mesh = handle->mesh();
  if (!mesh && throw_exception)
    ARCANE_FATAL("no mesh named '{0}' found", name);
  return mesh;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ConstArrayView<IMesh*> MeshMng::
meshes() const
{
  return m_meshes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMng::
destroyMeshes()
{
  for (MeshHandle& handle : m_meshes_handle) {
    IMesh* x = handle.mesh();
    if (x) {
      m_variable_mng->_internalApi()->detachMeshVariables(x);
      handle._destroyMesh();
    }
  }
  m_meshes_handle.clear();
  m_meshes.clear();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMng::
destroyMesh(MeshHandle handle)
{
  if (!handle.hasMesh())
    return;
  IMesh* mesh = handle.mesh();
  if (!mesh->isPrimaryMesh())
    ARCANE_FATAL("Can not destroy mesh '{0}' because it is not a primary mesh", mesh->name());
  _destroyMesh(mesh->toPrimaryMesh());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMng::
_destroyMesh(IPrimaryMesh* primary_mesh)
{
  IMesh* m = primary_mesh;
  String name = m->name();
  MeshHandle handle = m->handle();
  m_variable_mng->_internalApi()->detachMeshVariables(m);
  handle._destroyMesh();
 
  // Removes the mesh from the list.
  for (Integer i = 0, n = m_meshes.size(); i < n; ++i) {
    if (m_meshes[i] == m) {
      m_meshes.remove(i);
      break;
    }
  }
 
  // Removes the MeshHandle from the list
  for (Integer i = 0, n = m_meshes_handle.size(); i < n; ++i) {
    if (m_meshes_handle[i].meshName() == name) {
      m_meshes_handle.remove(i);
      break;
    }
  }
 
  _rebuildMeshList();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle MeshMng::
_addMeshHandle(const String& name)
{
  //std::cout << "_ADD_MESH_HANDLE handle=" << name << "\n";
  MeshHandle handle(m_variable_mng->_internalApi()->internalSubDomain(), name);
  m_meshes_handle.add(handle);
  return handle;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMng::
_rebuildMeshList()
{
  m_meshes.clear();
  for (MeshHandle& h : m_meshes_handle) {
    if (!h.hasMesh())
      continue;
    m_meshes.add(h.mesh());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshFactoryMng* MeshMng::
meshFactoryMng() const
{
  return m_mesh_factory_mng;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle MeshMng::
createDefaultMeshHandle(const String& name)
{
  m_default_mesh_handle = createMeshHandle(name);
  return m_default_mesh_handle;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/