MeshFactoryMng.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshFactoryMng.cc                                           (C) 2000-2023 */
/*                                                                           */
/* Mesh factory manager.                                                     */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/impl/internal/MeshFactoryMng.h"
 
#include "arcane/impl/internal/MeshMng.h"
 
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/MeshHandle.h"
#include "arcane/core/IPrimaryMesh.h"
#include "arcane/core/ServiceBuilder.h"
#include "arcane/core/IMeshFactory.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/MeshBuildInfo.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
namespace
{
 
  Ref<IMeshFactory>
  _getMeshFactory(IApplication* app, const MeshBuildInfo& mbi)
  {
    String factory_name = mbi.factoryName();
    ServiceBuilder<IMeshFactory> service_builder(app);
    Ref<IMeshFactory> mf = service_builder.createReference(factory_name, SB_AllowNull);
    if (!mf) {
      StringUniqueArray valid_names;
      service_builder.getServicesNames(valid_names);
      String valid_str = String::join(", ", valid_names);
      ARCANE_FATAL("No mesh factory named '{0}' found for creating mesh '{1}'."
                   " Valid values are {2}",
                   factory_name, mbi.name(), valid_str);
    }
    return mf;
  }
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshFactoryMng::
MeshFactoryMng(IApplication* app, MeshMng* mesh_mng)
: m_application(app)
, m_mesh_mng(mesh_mng)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshMng* MeshFactoryMng::
meshMng() const
{
  return m_mesh_mng;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshFactoryMng::
_checkValidBuildInfo(const MeshBuildInfo& build_info)
{
  if (build_info.name().empty())
    ARCANE_FATAL("Can not create mesh with null name()");
  if (build_info.factoryName().empty())
    ARCANE_FATAL("Can not create mesh with null factoryName()");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IPrimaryMesh* MeshFactoryMng::
createMesh(const MeshBuildInfo& build_info)
{
  _checkValidBuildInfo(build_info);
  ItemGroup parent_group = build_info.parentGroup();
  if (parent_group.null())
    return _createMesh(build_info);
  return _createSubMesh(build_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IPrimaryMesh* MeshFactoryMng::
_createMesh(const MeshBuildInfo& build_info)
{
  if (build_info.parallelMngRef().isNull())
    ARCANE_FATAL("Can not create mesh with null parallelMngRef()");
  String name = build_info.name();
  IMeshMng* mesh_mng = m_mesh_mng;
  MeshHandle* old_mesh_handle = mesh_mng->findMeshHandle(name, false);
  if (old_mesh_handle) {
    IMesh* old_mesh = old_mesh_handle->_internalMeshOrNull();
    if (old_mesh) {
      IPrimaryMesh* prm = dynamic_cast<IPrimaryMesh*>(old_mesh);
      if (!prm)
        ARCANE_FATAL("A mesh with same name already exists and is not a primary mesh");
      return prm;
    }
  }
 
  Ref<IMeshFactory> mesh_factory(_getMeshFactory(m_application, build_info));
 
  // Register the handle first because createMesh() uses it.
  // It is possible that a handle for this mesh has already been created
  // (This is especially true for the default mesh).
  // In this case, check that the mesh to be created does not have a handle
  // and if findMeshHandle() returns null, the handle will be created.
  MeshHandle* mh = mesh_mng->findMeshHandle(name, false);
  if (!mh)
    mesh_mng->createMeshHandle(name);
  IPrimaryMesh* mesh = mesh_factory->createMesh(m_mesh_mng, build_info);
  m_mesh_mng->addMesh(mesh);
  mesh->build();
  return mesh;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IPrimaryMesh* MeshFactoryMng::
_createSubMesh(const MeshBuildInfo& orig_build_info)
{
  ItemGroup group = orig_build_info.parentGroup();
  IMesh* mesh = group.mesh();
  ARCANE_CHECK_POINTER(mesh);
 
  if (mesh->meshMng() != m_mesh_mng)
    ARCANE_FATAL("This mesh has not been created by this factory");
  if (group.isAllItems())
    ARCANE_FATAL("Cannot create sub-mesh from all-items group");
 
  MeshBuildInfo build_info(orig_build_info);
  String name = build_info.name();
  // For a sub-mesh, the IParallelMng must necessarily be that of
  // the parent mesh
  build_info.addParallelMng(makeRef(mesh->parallelMng()));
 
  Ref<IMeshFactory> mesh_factory(_getMeshFactory(m_application, build_info));
 
  // Register the handle first because createMesh() uses it.
  // TODO: do this in the 'DynamicMesh' constructor and position
  // the handle also in the constructor.
  m_mesh_mng->createMeshHandle(name);
  IPrimaryMesh* sub_mesh = mesh_factory->createMesh(m_mesh_mng, build_info);
  m_mesh_mng->addMesh(sub_mesh);
 
  sub_mesh->defineParentForBuild(mesh, group);
  sub_mesh->build();
  mesh->addChildMesh(sub_mesh);
  return sub_mesh;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/