[arcane:cartesianmesh] Add methods to enable overlap cells layer

AlexlHer · AlexlHer · commit 524392de92dc · 2025-12-05T13:10:15.000+01:00
diff --git a/arcane/ceapart/src/arcane/tests/AMRCartesianMeshTesterModule.cc b/arcane/ceapart/src/arcane/tests/AMRCartesianMeshTesterModule.cc
@@ -513,6 +513,8 @@ void AMRCartesianMeshTesterModule::
 _initAMR()
 {
   CartesianMeshAMRMng amr_mng(m_cartesian_mesh);
+  amr_mng.enableOverlapLayer(false);
+
   // Regarde si on dé-raffine le maillage initial
   if (options()->coarseAtInit()){
     // Il faut que les directions aient été calculées avant d'appeler le dé-raffinement
@@ -842,7 +844,7 @@ _checkDirections()
     }
 
     if (cell_hash != expected_hash)
-      ARCANE_FATAL("Bad hash for uniqueId() for direction items of family '{0}' v= {1} expected='{2}'",
+      ARCANE_FATAL("Bad hash for uniqueId() for direction items of family '{0}' v='{1}' expected='{2}'",
                    item_family->fullName(), cell_hash, expected_hash);
   };
 
diff --git a/arcane/src/arcane/cartesianmesh/CartesianMeshAMRMng.cc b/arcane/src/arcane/cartesianmesh/CartesianMeshAMRMng.cc
@@ -90,13 +90,42 @@ coarseZone(const AMRZonePosition& position) const
 /*---------------------------------------------------------------------------*/
 
 void CartesianMeshAMRMng::
-adaptMesh(bool clear_refine_flag) const
+adaptMesh() const
 {
+  /*
+   * Dans le cas d'un raffinement niveau par niveau, il est possible de mettre
+   * le paramètre \a clear_refine_flag à false afin de garder les flags des
+   * niveaux inférieurs et d'éviter d'avoir à les recalculer. Pour le dernier
+   * niveau, il est recommandé de mettre le paramètre \a clear_refine_flag à
+   * true pour supprimer les flags devenu inutiles (ou d'appeler la méthode
+   * clearRefineRelatedFlags()).
+   *
+   * Les mailles n'ayant pas de flag "II_Refine" seront déraffinées.
+   *
+   * Afin d'éviter les mailles orphelines, si une maille est marquée
+   * "II_Refine", alors la maille parente est marquée "II_Refine".
+   *
+   * Exemple d'exécution :
+   * ```
+   * CartesianMeshAMRMng amr_mng(cmesh());
+   * amr_mng.clearRefineRelatedFlags();
+   * for (Integer level = 0; level < 2; ++level){
+   *   computeInLevel(level); // Va mettre des flags II_Refine sur les mailles
+   *   amr_mng.adaptMesh(false);
+   * }
+   * amr_mng.clearRefineRelatedFlags();
+   * ```
+   *
+   * Cette opération est collective.
+   *
+   * \param clear_refine_flag true si l'on souhaite supprimer les flags
+   * II_Refine après adaptation.
+   */
   auto amr_type = m_cmesh->mesh()->meshKind().meshAMRKind();
   if (amr_type == eMeshAMRKind::Cell) {
     ARCANE_FATAL("Method available only with AMR PatchCartesianMeshOnly");
   }
-  m_cmesh->_internalApi()->cartesianPatchGroup().refine(clear_refine_flag);
+  m_cmesh->_internalApi()->cartesianPatchGroup().refine(true);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -111,6 +140,20 @@ clearRefineRelatedFlags() const
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void CartesianMeshAMRMng::
+enableOverlapLayer(bool enable) const
+{
+  auto amr_type = m_cmesh->mesh()->meshKind().meshAMRKind();
+  if (amr_type == eMeshAMRKind::Cell) {
+    return;
+  }
+  m_cmesh->_internalApi()->cartesianPatchGroup().setOverlapLayerSizeTopLevel(enable ? 2 : 0);
+  m_cmesh->computeDirections();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 Integer CartesianMeshAMRMng::
 reduceNbGhostLayers(Integer level, Integer target_nb_ghost_layers) const
 {
diff --git a/arcane/src/arcane/cartesianmesh/CartesianMeshAMRMng.h b/arcane/src/arcane/cartesianmesh/CartesianMeshAMRMng.h
@@ -105,6 +105,8 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianMeshAMRMng
    * \brief Méthode permettant d'adapter le raffinement du maillage selon les
    * mailles à raffiner.
    *
+   * \warning Méthode expérimentale.
+   *
    * Cette méthode ne peut être appelée que si le maillage est un maillage
    * AMR (IMesh::isAmrActivated()==true) et que le type de l'AMR est 3
    * (PatchCartesianMeshOnly).
@@ -115,13 +117,7 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianMeshAMRMng
    * déjà).
    * Pour être sûr de n'avoir aucun flag déjà présent sur le maillage, il est
    * possible d'appeler la méthode \a clearRefineRelatedFlags().
-   * Dans le cas d'un raffinement niveau par niveau, il est possible de mettre
-   * le paramètre \a clear_refine_flag à false afin de garder les flags des
-   * niveaux inférieurs et d'éviter d'avoir à les recalculer. Pour le dernier
-   * niveau, il est recommandé de mettre le paramètre \a clear_refine_flag à
-   * true pour supprimer les flags devenu inutiles (ou d'appeler la méthode
-   * clearRefineRelatedFlags()).
-   *
+
    * Les mailles n'ayant pas de flag "II_Refine" seront déraffinées.
    *
    * Afin d'éviter les mailles orphelines, si une maille est marquée
@@ -132,18 +128,16 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianMeshAMRMng
    * CartesianMeshAMRMng amr_mng(cmesh());
    * amr_mng.clearRefineRelatedFlags();
    * for (Integer level = 0; level < 2; ++level){
-   *   computeInLevel(level); // Va mettre des flags II_Refine sur les mailles
-   *   amr_mng.adaptMesh(false);
+   *   // Va faire ses calculs et mettre des flags II_Refine sur les mailles
+   *   // du niveau 0 jusqu'au niveau level.
+   *   computeInLevel(0, level);
+   *   amr_mng.adaptMesh();
    * }
-   * amr_mng.clearRefineRelatedFlags();
    * ```
    *
    * Cette opération est collective.
-   *
-   * \param clear_refine_flag true si l'on souhaite supprimer les flags
-   * II_Refine après adaptation.
    */
-  void adaptMesh(bool clear_refine_flag) const;
+  void adaptMesh() const;
 
   /*!
    * \brief Méthode permettant de supprimer les flags liés au raffinement de
@@ -159,7 +153,9 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianMeshAMRMng
    */
   void clearRefineRelatedFlags() const;
 
-  /*!
+  void enableOverlapLayer(bool enable) const;
+ 
+   /*!
    * \brief Méthode permettant de supprimer une ou plusieurs couches
    * de mailles fantômes sur un niveau de raffinement défini.
    *
diff --git a/arcane/src/arcane/cartesianmesh/internal/CartesianPatchGroup.cc b/arcane/src/arcane/cartesianmesh/internal/CartesianPatchGroup.cc
@@ -50,6 +50,8 @@ CartesianPatchGroup::
 CartesianPatchGroup(ICartesianMesh* cmesh)
 : m_cmesh(cmesh)
 , m_index_new_patches(1)
+, m_size_of_overlap_layer_sub_top_level(0)
+, m_higher_level(0)
 {}
 
 /*---------------------------------------------------------------------------*/
@@ -171,6 +173,9 @@ addPatch(CellGroup cell_group, Integer group_index)
     position.setMinPoint({ min[MD_DirX], min[MD_DirY], min[MD_DirZ] });
     position.setMaxPoint({ max[MD_DirX], max[MD_DirY], max[MD_DirZ] });
     position.setLevel(level_r);
+
+    if (level_r > m_higher_level)
+      m_higher_level = level_r;
   }
 
   auto* cdi = new CartesianMeshPatch(m_cmesh, group_index, position);
@@ -364,6 +369,14 @@ applyPatchEdit(bool remove_empty_patches)
     _removeMultiplePatches(m_patches_to_delete);
     m_patches_to_delete.clear();
   }
+
+  m_higher_level = 0;
+  for (const auto patch : m_amr_patches_pointer) {
+    const Integer level = patch->_internalApi()->positionRef().level();
+    if (level > m_higher_level) {
+      m_higher_level = level;
+    }
+  }
 }
 
 /*---------------------------------------------------------------------------*/
@@ -399,6 +412,9 @@ updateLevelsBeforeAddGroundPatch()
     // Sinon, on "surélève" le niveau des patchs vu qu'il va y avoir le patch "-1"
     else {
       patch->_internalApi()->positionRef().setLevel(level + 1);
+      if (level + 1 > m_higher_level) {
+        m_higher_level = level + 1;
+      }
     }
   }
 }
@@ -504,11 +520,17 @@ mergePatches()
 void CartesianPatchGroup::
 refine(bool clear_refine_flag)
 {
+  // TODO : Le paramètre clear_refine_flag doit être à true pour l'instant.
+  //        À cause des mailles de recouvrements, on doit regénérer les patchs
+  //        de tous les niveaux à chaque fois. Pour que ça fonctionne, il
+  //        faudrait demander le nombre de niveaux qui sera généré en tout,
+  //        pour cette itération, pour calculer en avance la taille de la
+  //        couche de recouvrement de chaque niveau.
   if (m_cmesh->mesh()->meshKind().meshAMRKind() != eMeshAMRKind::PatchCartesianMeshOnly) {
     ARCANE_FATAL("Method available only with AMR PatchCartesianMeshOnly");
   }
   Integer dimension = m_cmesh->mesh()->dimension();
-  Integer nb_overlap_cells = 1;
+  Integer nb_overlap_cells = m_size_of_overlap_layer_sub_top_level;
   Integer min_level = 0;
   Integer future_max_level = -1; // Désigne le niveau max qui aura des enfants, donc le futur level max +1.
   Integer old_max_level = -1; // Mais s'il reste des mailles à des niveaux plus haut, il faut les retirer.
@@ -558,7 +580,7 @@ refine(bool clear_refine_flag)
     AMRPatchPosition all_level;
     all_level.setLevel(level);
     all_level.setMinPoint({ 0, 0, 0 });
-    all_level.setMaxPoint({ static_cast<Integer>(numbering->globalNbCellsX(level)), static_cast<Integer>(numbering->globalNbCellsY(level)), static_cast<Integer>(numbering->globalNbCellsZ(level)) });
+    all_level.setMaxPoint({ numbering->globalNbCellsX(level), numbering->globalNbCellsY(level), numbering->globalNbCellsZ(level) });
     all_level.setOverlapLayerSize(nb_overlap_cells);
 
     AMRPatchPositionSignature sig(all_level, m_cmesh, &all_patches);
@@ -843,6 +865,35 @@ availableGroupIndex()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void CartesianPatchGroup::
+setOverlapLayerSizeTopLevel(Integer size_of_overlap_layer_top_level)
+{
+  m_size_of_overlap_layer_sub_top_level = (size_of_overlap_layer_top_level + 1) / 2;
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+Integer CartesianPatchGroup::
+overlapLayerSize(Integer level)
+{
+  if (level < 0 || level > m_higher_level) {
+    ARCANE_FATAL("Level doesn't exist");
+  }
+  if (level == m_higher_level) {
+    return m_size_of_overlap_layer_sub_top_level * 2;
+  }
+  Integer nb_overlap_cells = m_size_of_overlap_layer_sub_top_level;
+  for (Integer i = m_higher_level - 1; i > level; --i) {
+    nb_overlap_cells /= 2;
+    nb_overlap_cells += 1;
+  }
+  return nb_overlap_cells;
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 void CartesianPatchGroup::
 _addPatchInstance(Ref<CartesianMeshPatch> v)
 {
@@ -1233,6 +1284,9 @@ _splitPatch(Integer index_patch, const AMRPatchPosition& part_to_remove)
 void CartesianPatchGroup::
 _addCutPatch(const AMRPatchPosition& new_patch_position, CellGroup parent_patch_cell_group)
 {
+  // Si cette méthode est utilisé par une autre méthode que _splitPatch(),
+  // voir si la mise à jour de m_higher_level est nécessaire.
+  // (jusque-là, ce n'est pas utile vu qu'il y aura appel à applyPatchEdit()).
   if (parent_patch_cell_group.null())
     ARCANE_FATAL("Null cell group");
 
@@ -1250,7 +1304,7 @@ _addCutPatch(const AMRPatchPosition& new_patch_position, CellGroup parent_patch_
     Int64 pos_x = numbering->cellUniqueIdToCoordX(*icell);
     Int64 pos_y = numbering->cellUniqueIdToCoordY(*icell);
     Int64 pos_z = numbering->cellUniqueIdToCoordZ(*icell);
-    if (new_patch_position.isIn(pos_x, pos_y, pos_z)) { // TODO : Ajouter overlap dans .arc
+    if (new_patch_position.isIn(pos_x, pos_y, pos_z)) {
       cells_local_id.add(icell.localId());
     }
   }
@@ -1293,6 +1347,10 @@ _addPatch(const AMRPatchPosition& new_patch_position)
   CellGroup parent_cells = cell_family->createGroup(patch_group_name, cells_local_id, true);
   _addCellGroup(parent_cells, cdi);
 
+  if (new_patch_position.level() > m_higher_level) {
+    m_higher_level = new_patch_position.level();
+  }
+
   // m_cmesh->traceMng()->info() << "_addPatch()"
   //                             << " -- m_amr_patch_cell_groups : " << m_amr_patch_cell_groups_all.size()
   //                             << " -- m_amr_patches : " << m_amr_patches.size()
diff --git a/arcane/src/arcane/cartesianmesh/internal/CartesianPatchGroup.h b/arcane/src/arcane/cartesianmesh/internal/CartesianPatchGroup.h
@@ -79,6 +79,9 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianPatchGroup
 
   ConstArrayView<Int32> availableGroupIndex();
 
+  void setOverlapLayerSizeTopLevel(Integer size_of_overlap_layer_top_level);
+  Integer overlapLayerSize(Integer level);
+
  private:
 
   Integer _nextIndexForNewPatch();
@@ -108,6 +111,8 @@ class ARCANE_CARTESIANMESH_EXPORT CartesianPatchGroup
   UniqueArray<Integer> m_patches_to_delete;
   Int32 m_index_new_patches;
   UniqueArray<Integer> m_available_group_index;
+  Integer m_size_of_overlap_layer_sub_top_level;
+  Integer m_higher_level;
 };
 
 /*---------------------------------------------------------------------------*/
