Merge pull request #2008 from arcaneframework/dev/gg-add-direct-compute-nodes-owner

Add support in `ItemsOwnerBuilder` to compute owners for nodes

Author: grospelliergilles

arcane/src/arcane/core/IMeshUtilities.h

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* IMeshUtilities.h                                            (C) 2000-2024 */
+/* IMeshUtilities.h                                            (C) 2000-2025 */
 /*                                                                           */
 /* Interface d'une classe proposant des fonctions utilitaires sur maillage.  */
 /*---------------------------------------------------------------------------*/
@@ -131,9 +131,36 @@ class ARCANE_CORE_EXPORT IMeshUtilities
    * En considérant que les nouveaux propriétaires des mailles sont
    * connus (et synchronisés), détermine les nouveaux propriétaires des autres
    * entités et les synchronise.
+   *
+   * Cette méthode est collective.
+   *
+   * \note Cette méthode nécessite que les informations de synchronisations soient
+   * valides. Si on souhaite déterminer les propriétaires des entités sans
+   * information préalable, il faut utiliser computeAndSetOwnersForNodes()
+   * ou computeAndSetOwnersForFaces().
    */
   virtual void changeOwnersFromCells() =0;
 
+  /*!
+   * \brief Détermine les propriétaires des noeuds.
+   *
+   * La détermination se fait en fonction des propriétaires des mailles.
+   * Il ne doit pas y avoir de couches de mailles fantômes.
+   *
+   * Cette opération est collective.
+   */
+  virtual void computeAndSetOwnersForNodes() =0;
+
+  /*!
+   * \brief Détermine les propriétaires des faces.
+   *
+   * La détermination se fait en fonction des propriétaires des mailles.
+   * Il ne doit pas y avoir de couches de mailles fantômes.
+   *
+   * Cette opération est collective.
+   */
+  virtual void computeAndSetOwnersForFaces() =0;
+
   /*!
    * \brief Ecrit le maillage dans un fichier.
    *

arcane/src/arcane/mesh/ItemsOwnerBuilder.cc

@@ -29,8 +29,11 @@
 #include "arcane/parallel/BitonicSortT.H"
 
 #include "arcane/mesh/ItemInternalMap.h"
+#include "arcane/mesh/NodeFamily.h"
 #include "arcane/mesh/DynamicMesh.h"
 
+#include <unordered_set>
+
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
@@ -110,11 +113,12 @@ class ItemsOwnerBuilderImpl
 
  public:
 
-  explicit ItemsOwnerBuilderImpl(DynamicMesh* mesh);
+  explicit ItemsOwnerBuilderImpl(IMesh* mesh);
 
  public:
 
   void computeFacesOwner();
+  void computeNodesOwner();
 
  private:
 
@@ -195,10 +199,13 @@ class ItemsOwnerBuilderImpl::ItemOwnerInfoSortTraits
 /*---------------------------------------------------------------------------*/
 
 ItemsOwnerBuilderImpl::
-ItemsOwnerBuilderImpl(DynamicMesh* mesh)
+ItemsOwnerBuilderImpl(IMesh* mesh)
 : TraceAccessor(mesh->traceMng())
-, m_mesh(mesh)
 {
+  DynamicMesh* dm = dynamic_cast<DynamicMesh*>(mesh);
+  if (!dm)
+    ARCANE_FATAL("Mesh is not an instance of 'DynamicMesh'");
+  m_mesh = dm;
   if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_ITEMS_OWNER_BUILDER_IMPL_DEBUG_LEVEL", true))
     m_verbose_level = v.value();
 }
@@ -209,6 +216,8 @@ ItemsOwnerBuilderImpl(DynamicMesh* mesh)
 void ItemsOwnerBuilderImpl::
 computeFacesOwner()
 {
+  m_items_owner_info.clear();
+
   IParallelMng* pm = m_mesh->parallelMng();
   const Int32 my_rank = pm->commRank();
   ItemInternalMap& faces_map = m_mesh->facesMap();
@@ -253,6 +262,78 @@ computeFacesOwner()
   face_family.notifyItemsOwnerChanged();
 }
 
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+void ItemsOwnerBuilderImpl::
+computeNodesOwner()
+{
+  m_items_owner_info.clear();
+
+  IParallelMng* pm = m_mesh->parallelMng();
+  const Int32 my_rank = pm->commRank();
+  ItemInternalMap& faces_map = m_mesh->facesMap();
+  ItemInternalMap& nodes_map = m_mesh->nodesMap();
+  NodeFamily& node_family = m_mesh->trueNodeFamily();
+
+  info() << "** BEGIN ComputeNodesOwner nb_node=" << nodes_map.count();
+
+  // Place par défaut tous les noeuds dans ce sous-domaine
+  nodes_map.eachItem([&](Node node) {
+    node.mutableItemBase().setOwner(my_rank, my_rank);
+  });
+
+  // Parcours toutes les faces.
+  // Ne garde que celles qui sont frontières ou dont les propriétaires des
+  // deux mailles de part et d'autre sont différents de notre sous-domaine.
+  //UniqueArray<Int32> faces_to_add;
+  //faces_map.eachItem([&](Face face) {
+  //Int32 nb_cell = face.nbCell();
+  // if (nb_cell == 1)
+  //  faces_to_add.add(face.localId());
+  //});
+  //info() << "ItemsOwnerBuilder: NB_FACE_TO_ADD=" << faces_to_add.size();
+  const Int32 verbose_level = m_verbose_level;
+
+  // Ajoute tous les noeuds des faces frontières.
+  std::unordered_set<Int32> done_nodes;
+
+  FaceInfoListView faces(m_mesh->faceFamily());
+  UniqueArray<Int32> nodes_to_add;
+  faces_map.eachItem([&](Face face) {
+    Int32 face_nb_cell = face.nbCell();
+    if (face_nb_cell == 1)
+      return;
+    for (Node node : face.nodes()) {
+      Int32 node_id = node.localId();
+      if (done_nodes.find(node_id) == done_nodes.end()) {
+        nodes_to_add.add(node_id);
+        done_nodes.insert(node_id);
+        node.mutableItemBase().setOwner(A_NULL_RANK, my_rank);
+      }
+    }
+  });
+
+  info() << "ItemsOwnerBuilder: NB_NODE_TO_ADD=" << nodes_to_add.size();
+  NodeInfoListView nodes(&node_family);
+  for (Int32 lid : nodes_to_add) {
+    Node node(nodes[lid]);
+    Int64 node_uid = node.uniqueId();
+    for (Cell cell : node.cells()) {
+      if (verbose_level >= 2)
+        info() << "ADD lid=" << lid << " uid=" << node_uid << " cell_uid=" << cell.uniqueId() << " owner=" << cell.owner();
+      m_items_owner_info.add(ItemOwnerInfo(node_uid, node_uid, cell.uniqueId(), my_rank, cell.owner()));
+    }
+  }
+
+  // Tri les instances de ItemOwnerInfo et les place les valeurs triées
+  // dans items_owner_info.
+  _sortInfos();
+  _processSortedInfos(nodes_map);
+
+  node_family.notifyItemsOwnerChanged();
+}
+
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 /*!
@@ -416,7 +497,7 @@ _processSortedInfos(ItemInternalMap& items_map)
 /*---------------------------------------------------------------------------*/
 
 ItemsOwnerBuilder::
-ItemsOwnerBuilder(DynamicMesh* mesh)
+ItemsOwnerBuilder(IMesh* mesh)
 : m_p(std::make_unique<ItemsOwnerBuilderImpl>(mesh))
 {}
 
@@ -427,6 +508,9 @@ ItemsOwnerBuilder::
   // pas connu dans le '.h'.
 }
 
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 void ItemsOwnerBuilder::
 computeFacesOwner()
 {
@@ -436,6 +520,15 @@ computeFacesOwner()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void ItemsOwnerBuilder::
+computeNodesOwner()
+{
+  m_p->computeNodesOwner();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 } // namespace Arcane::mesh
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/mesh/ItemsOwnerBuilder.h

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* ItemsOwnerBuilder.h                                         (C) 2000-2024 */
+/* ItemsOwnerBuilder.h                                         (C) 2000-2025 */
 /*                                                                           */
 /* Classe pour calculer les propriétaires des entités.                       */
 /*---------------------------------------------------------------------------*/
@@ -20,7 +20,10 @@
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
-
+namespace Arcane
+{
+class IMesh;
+}
 namespace Arcane::mesh
 {
 class ItemsOwnerBuilderImpl;
@@ -39,12 +42,13 @@ class ARCANE_MESH_EXPORT ItemsOwnerBuilder
 
  public:
 
-  explicit ItemsOwnerBuilder(DynamicMesh* mesh);
+  explicit ItemsOwnerBuilder(IMesh* mesh);
   ~ItemsOwnerBuilder();
 
  public:
 
   void computeFacesOwner();
+  void computeNodesOwner();
 
  private:
 

arcane/src/arcane/mesh/UnstructuredMeshUtilities.cc

@@ -51,6 +51,7 @@
 #include "arcane/mesh/BasicItemPairGroupComputeFunctor.h"
 #include "arcane/mesh/MeshNodeMerger.h"
 #include "arcane/mesh/ConnectivityNewWithDependenciesTypes.h"
+#include "arcane/mesh/ItemsOwnerBuilder.h"
 
 #include <algorithm>
 
@@ -815,6 +816,26 @@ mergeNodes(Int32ConstArrayView nodes_local_id,
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void UnstructuredMeshUtilities::
+computeAndSetOwnersForNodes()
+{
+  mesh::ItemsOwnerBuilder owner_builder(m_mesh);
+  owner_builder.computeNodesOwner();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+void UnstructuredMeshUtilities::
+computeAndSetOwnersForFaces()
+{
+  mesh::ItemsOwnerBuilder owner_builder(m_mesh);
+  owner_builder.computeFacesOwner();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 } // End namespace Arcane
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/mesh/UnstructuredMeshUtilities.h

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* UnstructuredMeshUtilities.h                                 (C) 2000-2024 */
+/* UnstructuredMeshUtilities.h                                 (C) 2000-2025 */
 /*                                                                           */
 /* Fonctions utilitaires sur un maillage.                                    */
 /*---------------------------------------------------------------------------*/
@@ -92,6 +92,9 @@ class UnstructuredMeshUtilities
   void mergeNodes(Int32ConstArrayView nodes_local_id,
                   Int32ConstArrayView nodes_to_merge_local_id) override;
 
+  void computeAndSetOwnersForNodes() override;
+  void computeAndSetOwnersForFaces() override;
+
  private:
 
   IMesh* m_mesh;

arcane/src/arcane/tests/CMakeLists.txt

@@ -673,6 +673,7 @@ if (ARCANE_DEFAULT_PARTITIONER_IS_METIS)
 endif()
 arcane_add_test_sequential(mesh2_generate_edge_face_uid_env testMesh-2-env-generate-edge-face-uid.arc "-We,ARCANE_GENERATE_UNIQUE_ID_FROM_NODES,1")
 arcane_add_test_sequential(mesh2_sort_faces testMesh-2-sorted-faces.arc)
+arcane_add_test(mesh2_compute_owners_direct testMesh-2-compute-owners-direct.arc)
 arcane_add_test_sequential(mesh2_init_nan testMesh-2.arc "-We,ARCANE_DATA_INIT_POLICY,NAN")
 arcane_add_test_sequential(mesh2_init_default testMesh-2.arc "-We,ARCANE_DATA_INIT_POLICY,DEFAULT" "-We,ARCANE_ITEMFAMILY_SHRINK_AFTER_ALLOCATE,1")
 arcane_add_test_sequential(mesh2_init_nan_and_default testMesh-2.arc "-We,ARCANE_DATA_INIT_POLICY,NAN_AND_DEFAULT")

arcane/src/arcane/tests/MeshUnitTest.axl

@@ -182,5 +182,11 @@ Teste la désallocation du maillage
     </description>
   </simple>
 
+  <simple name = "compute-owners-direct" type = "bool" default = "false">
+    <description>
+      Si vrai, utilise 'ItemsOwnerBuilder' pour calculer les propriétaires des noeuds et faces.
+    </description>
+  </simple>
+
  </options>
 </service>

arcane/src/arcane/tests/MeshUnitTest.cc

@@ -204,6 +204,7 @@ class MeshUnitTest
   void _testFindOneItem();
   void _testEvents();
   void _testNodeNodeViaEdgeConnectivity();
+  void _testComputeOwnersDirect();
 };
 
 /*---------------------------------------------------------------------------*/
@@ -246,6 +247,10 @@ buildInitializeTest()
 void MeshUnitTest::
 executeTest()
 {
+  bool do_compute_owners_direct = options()->computeOwnersDirect();
+  if (do_compute_owners_direct)
+    _testComputeOwnersDirect();
+
   bool do_sort_faces_and_edges = options()->testSortNodeFacesAndEdges();
   if (do_sort_faces_and_edges) {
     mesh()->nodeFamily()->properties()->setBool("sort-connected-faces-edges",true);
@@ -1796,6 +1801,19 @@ _testNodeNodeViaEdgeConnectivity()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void MeshUnitTest::
+_testComputeOwnersDirect()
+{
+  info() << "Test: _testComputeOwnersDirect()";
+  mesh()->modifier()->setDynamic(true);
+  mesh()->modifier()->updateGhostLayers();
+  mesh()->utilities()->computeAndSetOwnersForNodes();
+  mesh()->utilities()->computeAndSetOwnersForFaces();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 } // End namespace ArcaneTest
 
 /*---------------------------------------------------------------------------*/

arcane/tests/testMesh-2-compute-owners-direct.arc

@@ -0,0 +1,19 @@
+<?xml version="1.0" ?>
+<cas codename="ArcaneTest" xml:lang="fr" codeversion="1.0">
+  <arcane>
+    <titre>Test Maillage 1</titre>
+    <description>Test Maillage 1</description>
+    <boucle-en-temps>UnitTest</boucle-en-temps>
+  </arcane>
+
+  <maillage nb-ghostlayer='0' ghostlayer-builder-version="3">
+    <fichier internal-partition="true">sod.vtk</fichier>
+  </maillage>
+
+  <module-test-unitaire>
+    <test name="MeshUnitTest">
+      <compute-owners-direct>true</compute-owners-direct>
+    </test>
+  </module-test-unitaire>
+
+</cas>