MeshUtils.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshUtils.h                                                 (C) 2000-2024 */
/*                                                                           */
/* Fonctions utilitaires diverses sur le maillage.                           */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_MESHUTILS_H
#define ARCANE_CORE_MESHUTILS_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FunctorUtils.h"
#include "arcane/utils/MemoryUtils.h"
 
#include "arcane/Item.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class XmlNode;
class IVariableSynchronizer;
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::MeshUtils
{
extern "C++" ARCANE_CORE_EXPORT void
writeMeshItemInfo(ISubDomain*, Cell cell, bool depend_info = true);
extern "C++" ARCANE_CORE_EXPORT void
writeMeshItemInfo(ISubDomain*, Node node, bool depend_info = true);
extern "C++" ARCANE_CORE_EXPORT void
writeMeshItemInfo(ISubDomain*, Edge edge, bool depend_info = true);
extern "C++" ARCANE_CORE_EXPORT void
writeMeshItemInfo(ISubDomain*, Face face, bool depend_info = true);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT bool
reorderNodesOfFace(Int64ConstArrayView before_ids, Int64ArrayView after_ids);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT bool
reorderNodesOfFace2(Int64ConstArrayView nodes_unique_id, IntegerArrayView new_index);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT Face
getFaceFromNodesLocal(Node node, Int32ConstArrayView face_nodes_local_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT Face
getFaceFromNodesUnique(Node node, Int64ConstArrayView face_nodes_unique_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT Int64
generateHashUniqueId(SmallSpan<const Int64> nodes_unique_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C++" ARCANE_CORE_EXPORT void
removeItemAndKeepOrder(Int32ArrayView items, Int32 local_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
checkMeshProperties(IMesh* mesh, bool is_sorted, bool has_no_hole, bool check_faces);
 
extern "C++" ARCANE_CORE_EXPORT void
writeMeshInfosSorted(IMesh* mesh, const String& file_name);
 
extern "C++" ARCANE_CORE_EXPORT void
writeMeshInfos(IMesh* mesh, const String& file_name);
 
extern "C++" ARCANE_CORE_EXPORT void
writeMeshConnectivity(IMesh* mesh, const String& file_name);
 
extern "C++" ARCANE_CORE_EXPORT void
checkMeshConnectivity(IMesh* mesh, const XmlNode& root_node, bool check_sub_domain);
 
extern "C++" ARCANE_CORE_EXPORT void
checkMeshConnectivity(IMesh* mesh, const String& file_name, bool check_sub_domain);
 
extern "C++" ARCANE_CORE_EXPORT void
printItems(std::ostream& ostr, const String& name, ItemGroup item_group);
 
extern "C++" ARCANE_CORE_EXPORT Int64
printMeshGroupsMemoryUsage(IMesh* mesh, Int32 print_level);
 
extern "C++" ARCANE_CORE_EXPORT void
shrinkMeshGroups(IMesh* mesh);
 
extern "C++" ARCANE_CORE_EXPORT void
dumpSynchronizerTopologyJSON(IVariableSynchronizer* var_syncer, const String& filename);
 
extern "C++" ARCANE_CORE_EXPORT void
computeConnectivityPatternOccurence(IMesh* mesh);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
markMeshConnectivitiesAsMostlyReadOnly(IMesh* mesh,RunQueue* q = nullptr,
                                       bool do_prefetch = false);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * \brief Retourne l'entité de la famille \a family de numéro unique \a unique_id.
 *
 * Si aucune entité avec cet \a unique_id n'est trouvé, retourne l'entité nulle.
 *
 * \pre family->hasUniqueIdMap() == true
 */
extern "C++" ARCANE_CORE_EXPORT impl::ItemBase
findOneItem(IItemFamily* family, Int64 unique_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * \brief Retourne l'entité de la famille \a family de numéro unique \a unique_id.
 *
 * Si aucune entité avec cet \a unique_id n'est trouvé, retourne l'entité nulle.
 *
 * \pre family->hasUniqueIdMap() == true
 */
extern "C++" ARCANE_CORE_EXPORT impl::ItemBase
findOneItem(IItemFamily* family, ItemUniqueId unique_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
visitGroups(IItemFamily* family, IFunctorWithArgumentT<ItemGroup&>* functor);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
visitGroups(IMesh* mesh, IFunctorWithArgumentT<ItemGroup&>* functor);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename LambdaType> inline void
visitGroups(IItemFamily* family, const LambdaType& f)
{
  StdFunctorWithArgumentT<ItemGroup&> sf(f);
  // Il faut caster en le bon type pour que le compilateur utilise la bonne surcharge.
  IFunctorWithArgumentT<ItemGroup&>* sf_addr = &sf;
  visitGroups(family, sf_addr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename LambdaType> inline void
visitGroups(IMesh* mesh, const LambdaType& f)
{
  StdFunctorWithArgumentT<ItemGroup&> sf(f);
  // Il faut caster en le bon pour que le compilateur utilise la bonne surcharge.
  IFunctorWithArgumentT<ItemGroup&>* sf_addr = &sf;
  visitGroups(mesh, sf_addr);
}
 
namespace impl
{
  inline Int64 computeCapacity(Int64 size)
  {
    return Arcane::MemoryUtils::impl::computeCapacity(size);
  }
} // namespace impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename DataType> inline bool
checkResizeArray(Array<DataType>& array, Int64 new_size, bool force_resize)
{
  return Arcane::MemoryUtils::checkResizeArrayWithCapacity(array, new_size, force_resize);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT ItemUniqueId
getMaxItemUniqueIdCollective(IMesh* mesh);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
checkUniqueIdsHashCollective(IItemFamily* family, IHashAlgorithm* hash_algo,
                             const String& expected_hash, bool print_hash_value,
                             bool include_ghost);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCANE_CORE_EXPORT void
fillUniqueIds(ItemVectorView items,Array<Int64>& uids);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C++" ARCANE_CORE_EXPORT Ref<IIndexedIncrementalItemConnectivity>
computeNodeNodeViaEdgeConnectivity(IMesh* mesh, const String& connectivity_name);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::MeshUtils
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh_utils
{
// Using pour compatibilité avec l'existant.
// Ces using ont été ajoutés pour la version 3.10 de Arcane (juin 2023).
// On pourra les rendre obsolètes début 2024.
using MeshUtils::checkMeshConnectivity;
using MeshUtils::checkMeshProperties;
using MeshUtils::computeConnectivityPatternOccurence;
using MeshUtils::dumpSynchronizerTopologyJSON;
using MeshUtils::getFaceFromNodesLocal;
using MeshUtils::getFaceFromNodesUnique;
using MeshUtils::printItems;
using MeshUtils::printMeshGroupsMemoryUsage;
using MeshUtils::removeItemAndKeepOrder;
using MeshUtils::reorderNodesOfFace;
using MeshUtils::reorderNodesOfFace2;
using MeshUtils::shrinkMeshGroups;
using MeshUtils::writeMeshConnectivity;
using MeshUtils::writeMeshInfos;
using MeshUtils::writeMeshInfosSorted;
using MeshUtils::writeMeshItemInfo;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::mesh_utils
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif