Arcane  v3.16.9.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MeshUtils.h
Aller à la documentation de ce fichier.
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* MeshUtils.h (C) 2000-2025 */
9/* */
10/* Fonctions utilitaires diverses sur le maillage. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_MESHUTILS_H
13#define ARCANE_CORE_MESHUTILS_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/FunctorUtils.h"
19
20#include "arcane/core/Item.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24/*!
25 * \file MeshUtils.h
26 *
27 * \brief Fonctions utilitaires sur le maillage.
28 */
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32namespace Arcane
33{
34class XmlNode;
36} // namespace Arcane
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
40
41namespace Arcane::MeshUtils
42{
43extern "C++" ARCANE_CORE_EXPORT void
44writeMeshItemInfo(ISubDomain*, Cell cell, bool depend_info = true);
45extern "C++" ARCANE_CORE_EXPORT void
46writeMeshItemInfo(ISubDomain*, Node node, bool depend_info = true);
47extern "C++" ARCANE_CORE_EXPORT void
48writeMeshItemInfo(ISubDomain*, Edge edge, bool depend_info = true);
49extern "C++" ARCANE_CORE_EXPORT void
50writeMeshItemInfo(ISubDomain*, Face face, bool depend_info = true);
51
52/*---------------------------------------------------------------------------*/
53/*---------------------------------------------------------------------------*/
54/*!
55 * \brief Réordonne les noeuds d'une face.
56 *
57 * Cette méthode réordonne la liste des noeuds d'une face pour que les
58 * propriétés suivantes soient respectées:
59 * - le premier noeud de la face est celui dont le numéro global est le plus petit.
60 * - le deuxième noeud de la face est celui dont le numéro global est le deuxième plus petit.
61 *
62 * Cela permet d'orienter les faces de manière identiques en parallèle.
63 *
64 * \a before_ids et \a to doivent avoir le même nombre d'éléments
65 *
66 * \param before_ids numéros globaux des noeuds de la face avant renumérotation.
67 * \param after_ids en sortie, numéros globaux des noeuds de la face après renumérotation
68 *
69 * \retval true si la face change d'orientation lors de la renumérotation
70 * \retval false sinon.
71 */
72extern "C++" ARCANE_CORE_EXPORT bool
74
75extern "C++" ARCANE_CORE_EXPORT bool
77
78/*---------------------------------------------------------------------------*/
79/*---------------------------------------------------------------------------*/
80/*!
81 * \brief Réordonne les noeuds d'une face.
82 *
83 * Cette méthode réordonne la liste des noeuds d'une face pour que les
84 * propriétés suivantes soient respectées:
85 * - le premier noeud de la face est celui dont le numéro global est le plus petit.
86 * - le deuxième noeud de la face est celui dont le numéro global est le deuxième plus petit.
87 *
88 * Cela permet d'orienter les faces de manière identiques en parallèle.
89 *
90 * \a nodes_unique_id et \a new_index doivent avoir le même nombre d'éléments
91 *
92 * \param nodes_unique_id numéros uniques des noeuds de la face.
93 * \param new_index en sortie, position des numéros des noeuds après réorientation.
94 *
95 * Par exemple, si une face possède les 4 noeuds de numéros uniques 7 3 2 5,
96 * la réorientation donnera le quadruplet (2 3 7 5), soit le tableau d'index
97 * suivant (2,1,0,3).
98 *
99 * \retval true si la face change d'orientation lors de la renumérotation
100 * \retval false sinon.
101 */
102extern "C++" ARCANE_CORE_EXPORT bool
104
105/*---------------------------------------------------------------------------*/
106/*---------------------------------------------------------------------------*/
107/*!
108 * \brief Recherche une entité face à partir des numéros locaux de ces noeuds.
109 *
110 * Recherche la face donnée par la liste ordonnée des numéros <b>locaux</b> de
111 * ces noeuds \a face_nodes_local_id. \a node doit être le premier noeud de
112 * la face. Les noeuds de la face doivent être correctement orientés, comme
113 * après un appel à reorderNodesOfFace().
114 *
115 * \return la face correspondante ou la face nulle si elle n'est pas trouvé.
116 */
117extern "C++" ARCANE_CORE_EXPORT Face
118getFaceFromNodesLocalId(Node node, Int32ConstArrayView face_nodes_local_id);
119
120ARCANE_DEPRECATED_REASON("Y2025: Use getFaceFromNodesLocalId() instead")
121inline Face
122getFaceFromNodesLocal(Node node, Int32ConstArrayView face_nodes_local_id)
123{
124 return getFaceFromNodesLocalId(node, face_nodes_local_id);
125}
126
127/*---------------------------------------------------------------------------*/
128/*---------------------------------------------------------------------------*/
129/*!
130 * \brief Recherche une entité face à partir des numéros uniques de ces noeuds.
131 *
132 * Recherche la face donnée par la liste ordonnée des numéros <b>unique</b> de
133 * ces noeuds \a face_nodes_unique_id. \a node doit être le premier noeud de
134 * la face. Les noeuds de la face doivent être correctement orientés, comme
135 * après un appel à reorderNodesOfFace().
136 *
137 * \return la face correspondante ou la face nulle si elles n'est pas trouvé.
138 */
139extern "C++" ARCANE_CORE_EXPORT Face
140getFaceFromNodesUniqueId(Node node, Int64ConstArrayView face_nodes_unique_id);
141
142ARCANE_DEPRECATED_REASON("Y2025: Use getFaceFromNodesUniqueId() instead")
143inline Face
144getFaceFromNodesUnique(Node node, Int64ConstArrayView face_nodes_unique_id)
145{
146 return getFaceFromNodesUniqueId(node, face_nodes_unique_id);
147}
148
149/*---------------------------------------------------------------------------*/
150/*---------------------------------------------------------------------------*/
151/*!
152 * \brief Génère un identifiant unique à partir d'une liste d'identifiants de noeuds.
153 */
154extern "C++" ARCANE_CORE_EXPORT Int64
155generateHashUniqueId(SmallSpan<const Int64> nodes_unique_id);
156
157/*---------------------------------------------------------------------------*/
158/*---------------------------------------------------------------------------*/
159
160/*!
161 * \brief Supprime une entité en conservant l'ordre.
162 *
163 * Supprime l'entité de numéro local \a local_id de la liste \a items.
164 * Les entités situées après l'entité supprimée sont décalées pour remplir le trou.
165 * Si aucune valeur de \a items ne vaut \a local_id, une exception est levée.
166 */
167extern "C++" ARCANE_CORE_EXPORT void
168removeItemAndKeepOrder(Int32ArrayView items, Int32 local_id);
169
170/*---------------------------------------------------------------------------*/
171/*---------------------------------------------------------------------------*/
172/*!
173 * \brief Vérifie que le maillage possède certaines propriétés.
174 *
175 * Si \a is_sorted, vérifie que les entités de maillage sont triées par
176 * ordre croissant de leur uniqueId().
177 * Si \a has_no_hole est vrai, vérifie que si le maillage possède \a n
178 * entité d'un type, leur numéro local varie bien de \a 0 à \a n-1.
179 * Si \a check_faces est vrai, on vérifie pour les faces. Cette option
180 * n'est utilisable que pour les maillages ancienne génération (MeshV1) et
181 * sera supprimée dès que cette option ne sera plus utilisée.
182 */
183extern "C++" ARCANE_CORE_EXPORT void
184checkMeshProperties(IMesh* mesh, bool is_sorted, bool has_no_hole, bool check_faces);
185
186/*!
187 * \brief Ecrit sur le fichier \a file_name les infos du maillage \a mesh
188 *
189 * Les identifiants des entités sont triés pour que le maillage soit
190 * identique quel que soit la numérotation initiale.
191 */
192extern "C++" ARCANE_CORE_EXPORT void
193writeMeshInfosSorted(IMesh* mesh, const String& file_name);
194
195extern "C++" ARCANE_CORE_EXPORT void
196writeMeshInfos(IMesh* mesh, const String& file_name);
197
198/*!
199 * \brief Ecrit sur le fichier \a file_name la connectivité du maillage \a mesh
200 *
201 * La connectivité de chaque entité arête, face et maille est sauvée.
202 */
203extern "C++" ARCANE_CORE_EXPORT void
204writeMeshConnectivity(IMesh* mesh, const String& file_name);
205
206extern "C++" ARCANE_CORE_EXPORT void
207checkMeshConnectivity(IMesh* mesh, const XmlNode& root_node, bool check_sub_domain);
208
209extern "C++" ARCANE_CORE_EXPORT void
210checkMeshConnectivity(IMesh* mesh, const String& file_name, bool check_sub_domain);
211
212/*!
213 * \brief Ecrit dans le flux \a ostr la description des items du groupe \a item_group
214 *
215 * Pour l'affichage, un nom \a name est associé.
216 */
217extern "C++" ARCANE_CORE_EXPORT void
218printItems(std::ostream& ostr, const String& name, ItemGroup item_group);
219
220/*!
221 * \brief Affiche l'utilisation mémoire des groupes du maillage.
222 *
223 * Si \a print_level vaut 0, affiche uniquement l'usage mémoire total.
224 * So \a print_level vaut 1 ou plus, affiche l'usage pour chaque groupe.
225 *
226 * En retour, indique la mémoire consommée en octets.
227 */
228extern "C++" ARCANE_CORE_EXPORT Int64
229printMeshGroupsMemoryUsage(IMesh* mesh, Int32 print_level);
230
231//! Limite au plus juste l'usage mémoire des groupes.
232extern "C++" ARCANE_CORE_EXPORT void
233shrinkMeshGroups(IMesh* mesh);
234
235/*!
236 * \brief Ecrit dans un fichier les informations sur la topologie d'une synchronisation
237 *
238 * Ecrit dans le fichier \a filename les informations sur la topologie de \a var_syncer.
239 * Cette méthode est collective. Seul le rang 0 écrit l'information de la topologie.
240 */
241extern "C++" ARCANE_CORE_EXPORT void
242dumpSynchronizerTopologyJSON(IVariableSynchronizer* var_syncer, const String& filename);
243
244/*!
245 * \internal
246 * \brief Calcul et affiche les patterns communs dans les connectivités.
247 */
248extern "C++" ARCANE_CORE_EXPORT void
249computeConnectivityPatternOccurence(IMesh* mesh);
250
251/*---------------------------------------------------------------------------*/
252/*---------------------------------------------------------------------------*/
253/*!
254 * \brief Indique que les connectivités du maillages ne seront
255 * pas régulièrement modifiées.
256 *
257 * Cette fonction permet d'indiquer que les connectivitées associées aux
258 * entités du maillage (Node, Edge, Face et Cell) sont la plupart du temps
259 * en lecture. A noter que cela ne concerne pas les particules.
260 *
261 * En cas d'utilisation sur accélérateur, cela permet de dupliquer les
262 * informations entre l'accélérateur et l'hôte pour éviter des aller-retour
263 * multiples si les connectivités sont utilisées sur les deux à la fois.
264 *
265 * Si \a q est non nul et que \a do_prefetch vaut \a true, alors
266 * VariableUtils::prefetchVariableAsync() est appelé pour chaque variable
267 * gérant la connectivité.
268 */
269extern "C++" ARCANE_CORE_EXPORT void
270markMeshConnectivitiesAsMostlyReadOnly(IMesh* mesh, RunQueue* q = nullptr,
271 bool do_prefetch = false);
272
273/*---------------------------------------------------------------------------*/
274/*---------------------------------------------------------------------------*/
275/*
276 * \brief Retourne l'entité de la famille \a family de numéro unique \a unique_id.
277 *
278 * Si aucune entité avec cet \a unique_id n'est trouvé, retourne l'entité nulle.
279 *
280 * \pre family->hasUniqueIdMap() == true
281 */
282extern "C++" ARCANE_CORE_EXPORT ItemBase
283findOneItem(IItemFamily* family, Int64 unique_id);
284
285/*---------------------------------------------------------------------------*/
286/*---------------------------------------------------------------------------*/
287/*
288 * \brief Retourne l'entité de la famille \a family de numéro unique \a unique_id.
289 *
290 * Si aucune entité avec cet \a unique_id n'est trouvé, retourne l'entité nulle.
291 *
292 * \pre family->hasUniqueIdMap() == true
293 */
294extern "C++" ARCANE_CORE_EXPORT ItemBase
295findOneItem(IItemFamily* family, ItemUniqueId unique_id);
296
297/*---------------------------------------------------------------------------*/
298/*---------------------------------------------------------------------------*/
299/*!
300 * \brief Visite l'ensemble des groupes de \a family avec le functor \a functor.
301 */
302extern "C++" ARCANE_CORE_EXPORT void
303visitGroups(IItemFamily* family, IFunctorWithArgumentT<ItemGroup&>* functor);
304
305/*---------------------------------------------------------------------------*/
306/*---------------------------------------------------------------------------*/
307/*!
308 * \brief Visite l'ensemble des groupes de \a mesh avec le functor \a functor.
309 */
310extern "C++" ARCANE_CORE_EXPORT void
311visitGroups(IMesh* mesh, IFunctorWithArgumentT<ItemGroup&>* functor);
312
313/*---------------------------------------------------------------------------*/
314/*---------------------------------------------------------------------------*/
315/*!
316 * \brief Visite l'ensemble des groupes de \a family avec la lambda \a f.
317 *
318 * Cette fonction permet d'appliquer un visiteur pour l'ensemble des
319 * groupes de la famille \a family.
320 *
321 * Par exemple:
322 *
323 * \code
324 * IMesh* mesh = ...;
325 * auto xx = [](const ItemGroup& x) { std::cout << "name=" << x.name(); };
326 * MeshUtils::visitGroups(mesh,xx);
327 * \endcode
328 */
329template <typename LambdaType> inline void
330visitGroups(IItemFamily* family, const LambdaType& f)
331{
333 // Il faut caster en le bon type pour que le compilateur utilise la bonne surcharge.
335 visitGroups(family, sf_addr);
336}
337
338/*---------------------------------------------------------------------------*/
339/*---------------------------------------------------------------------------*/
340/*!
341 * \brief Visite l'ensemble des groupes de \a mesh avec la lambda \a f.
342 *
343 * Cette fonction permet d'appliquer un visiteur pour l'ensemble des
344 * groupes de l'ensemble des familles du maillage \a mesh
345 *
346 * Elle s'utilise comme suit:
347 *
348 * \code
349 * IMesh* mesh = ...;
350 * auto xx = [](const ItemGroup& x) { std::cout << "name=" << x.name(); };
351 * MeshVisitor::visitGroups(mesh,xx);
352 * \endcode
353 */
354template <typename LambdaType> inline void
355visitGroups(IMesh* mesh, const LambdaType& f)
356{
358 // Il faut caster en le bon pour que le compilateur utilise la bonne surcharge.
360 visitGroups(mesh, sf_addr);
361}
362
363namespace impl
364{
365 inline Int64 computeCapacity(Int64 size)
366 {
368 }
369} // namespace impl
370
371/*---------------------------------------------------------------------------*/
372/*---------------------------------------------------------------------------*/
373/*!
374 * \brief Redimensionne un tableau qui est indexé par des 'ItemLocalId'.
375 *
376 * Le tableau \a array est redimensionné uniquement si \a new_size est
377 * supérieure à la taille actuelle du tableau ou si \a force_resize est vrai.
378 *
379 * Si le tableau est redimensionné, on réserve une capacité supplémentaire
380 * pour éviter de réallouer à chaque fois.
381 *
382 * Cette fonction est appelée en général pour les tableaux indexés par un
383 * ItemLocalId et donc cette fonction peut être appelée à chaque fois qu'on
384 * ajoute une entité au maillage.
385 *
386 * \retval true si un redimensionnement a eu lieu
387 * \retval false sinon
388 */
389template <typename DataType> inline bool
390checkResizeArray(Array<DataType>& array, Int64 new_size, bool force_resize)
391{
392 return Arcane::MemoryUtils::checkResizeArrayWithCapacity(array, new_size, force_resize);
393}
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397/*!
398 * \brief Retourne le maximum des uniqueId() des entités standards du maillage.
399 *
400 * Les entités standards sont les noeuds, mailles, faces et arêtes.
401 * L'opération est collective sur mesh->parallelMng().
402 */
403extern "C++" ARCANE_CORE_EXPORT ItemUniqueId
404getMaxItemUniqueIdCollective(IMesh* mesh);
405
406/*---------------------------------------------------------------------------*/
407/*---------------------------------------------------------------------------*/
408/*!
409 * \brief Vérifie le hash des uniqueId() des entités d'une famille.
410 *
411 * Calcule via l'algo \a hash_algo un hash des uniqueId() des entités
412 * d'une famille. Pour ce calcul, le rang 0 récupère l'ensemble des uniqueId()
413 * des entités propres de chaque sous-domaine, les trie et calcul le hash
414 * sur le tableau trié.
415 *
416 * Comme la majorité du travail est effectuée par le rang 0, cette méthode
417 * n'est pas très extensible et ne doit donc être utilisée qu'à des fins
418 * de test.
419 *
420 * \a expected_hash est la valeur attendue du hash sous forme de caractères
421 * hexadécimaux (obtenu via Convert::toHexaString()). Si \a expected_hash
422 * est non nul, compare le résultat avec cette valeur et si elle est différente,
423 * lance une exception FatalErrorException.
424 *
425 * Cette opération est collective.
426 */
427extern "C++" ARCANE_CORE_EXPORT void
428checkUniqueIdsHashCollective(IItemFamily* family, IHashAlgorithm* hash_algo,
429 const String& expected_hash, bool print_hash_value,
430 bool include_ghost);
431
432/*---------------------------------------------------------------------------*/
433/*---------------------------------------------------------------------------*/
434/*!
435 * \brief Rempli \a uids avec les uniqueId() des entités de \a view.
436 */
437extern "C++" ARCANE_CORE_EXPORT void
438fillUniqueIds(ItemVectorView items,Array<Int64>& uids);
439
440/*---------------------------------------------------------------------------*/
441/*---------------------------------------------------------------------------*/
442
443/*!
444 * \brief Créé ou recréé une connectivité noeuds-noeuds via les arêtes.
445 *
446 * La connectivité aura pour nom \a connectivity_name.
447 */
448extern "C++" ARCANE_CORE_EXPORT Ref<IIndexedIncrementalItemConnectivity>
449computeNodeNodeViaEdgeConnectivity(IMesh* mesh, const String& connectivity_name);
450
451/*---------------------------------------------------------------------------*/
452/*---------------------------------------------------------------------------*/
453/*!
454 * \brief Créé ou recréé une connectivité noeuds-noeuds via les arêtes
455 * pour les noeuds sur les faces frontières du maillage.
456 *
457 * La connectivité aura pour nom \a connectivity_name.
458 */
459extern "C++" ARCANE_CORE_EXPORT Ref<IIndexedIncrementalItemConnectivity>
460computeBoundaryNodeNodeViaEdgeConnectivity(IMesh* mesh, const String& connectivity_name);
461
462/*---------------------------------------------------------------------------*/
463/*---------------------------------------------------------------------------*/
464
465} // namespace Arcane::MeshUtils
466
467/*---------------------------------------------------------------------------*/
468/*---------------------------------------------------------------------------*/
469
470namespace Arcane::mesh_utils
471{
472// Using pour compatibilité avec l'existant.
473// Ces using ont été ajoutés pour la version 3.10 de Arcane (juin 2023).
474// On pourra les rendre obsolètes début 2024.
475using MeshUtils::checkMeshConnectivity;
476using MeshUtils::checkMeshProperties;
477using MeshUtils::computeConnectivityPatternOccurence;
478using MeshUtils::dumpSynchronizerTopologyJSON;
479using MeshUtils::getFaceFromNodesLocal;
480using MeshUtils::getFaceFromNodesUnique;
481using MeshUtils::printItems;
482using MeshUtils::printMeshGroupsMemoryUsage;
483using MeshUtils::removeItemAndKeepOrder;
484using MeshUtils::reorderNodesOfFace;
485using MeshUtils::reorderNodesOfFace2;
486using MeshUtils::shrinkMeshGroups;
487using MeshUtils::writeMeshConnectivity;
488using MeshUtils::writeMeshInfos;
489using MeshUtils::writeMeshInfosSorted;
490using MeshUtils::writeMeshItemInfo;
491
492/*---------------------------------------------------------------------------*/
493/*---------------------------------------------------------------------------*/
494
495} // namespace Arcane::mesh_utils
496
497/*---------------------------------------------------------------------------*/
498/*---------------------------------------------------------------------------*/
499
500#endif
Fonctions de gestion mémoire et des allocateurs.
Int64 computeCapacity(Int64 size)
Calcule une capacité adaptée pour une taille de size.
bool checkResizeArray(Array< DataType > &array, Int64 new_size, bool force_resize)
Redimensionne un tableau qui est indexé par des 'ItemLocalId'.
Definition MeshUtils.h:390
bool reorderNodesOfFace(Int64ConstArrayView before_ids, Int64ArrayView after_ids)
Réordonne les noeuds d'une face.
void visitGroups(IItemFamily *family, IFunctorWithArgumentT< ItemGroup & > *functor)
Visite l'ensemble des groupes de family avec le functor functor.
bool reorderNodesOfFace2(Int64ConstArrayView nodes_unique_id, Int32ArrayView new_index)
Réordonne les noeuds d'une face.
Face getFaceFromNodesLocalId(Node node, Int32ConstArrayView face_nodes_local_id)
Recherche une entité face à partir des numéros locaux de ces noeuds.
Classe de base des vecteurs 1D de données.
Face d'une maille.
Definition Item.h:958
Interface d'un fonctor avec argument mais sans valeur de retour.
Interface d'un algorithme de hashage.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Interface d'un service de synchronisation de variable.
Identifiant unique d'une entité.
Vue sur un vecteur d'entités.
Noeud d'un maillage.
Definition Item.h:582
Référence à une instance.
Chaîne de caractères unicode.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Int32 checkResizeArrayWithCapacity(Array< DataType > &array, Int64 new_size, bool force_resize)
Redimensionne un tableau en ajoutant une réserve de mémoire.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
ArrayView< Int64 > Int64ArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:538
std::int64_t Int64
Type entier signé sur 64 bits.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:567
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:540
@ Cell
Le maillage est AMR par maille.
Definition MeshKind.h:52