MeshRefinement.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshRefinement.h                                            (C) 2000-2024 */
/*                                                                           */
/* Management of unstructured mesh adaptation by refinement                  */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MESH_MESHREFINEMENT_H
#define ARCANE_MESH_MESHREFINEMENT_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/TraceAccessor.h"
#include "arcane/utils/PerfCounterMng.h"
#include "arcane/utils/AMRCallBackMng.h"
 
#include "arcane/core/ItemRefinementPattern.h"
 
#include "arcane/mesh/MeshGlobal.h"
#include "arcane/mesh/MapCoordToUid.h"
#include "arcane/mesh/DynamicMeshKindInfos.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class IMesh;
class Node;
class Cell;
class AMRCallBackMng;
class FaceFamily;
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
class DynamicMesh;
class ItemRefinement;
class ParallelAMRConsistency;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class MeshRefinement
: public TraceAccessor
{
 public:
 
#ifdef ACTIVATE_PERF_COUNTER
  struct PerfCounter
  {
    typedef enum
    {
      INIT,
      CLEAR,
      ENDUPDATE,
      UPDATEMAP,
      UPDATEMAP2,
      CONSIST,
      PCONSIST,
      PCONSIST2,
      PGCONSIST,
      CONTRACT,
      COARSEN,
      REFINE,
      INTERP,
      PGHOST,
      COMPACT,
      NbCounters
    } eType;
 
    static const std::string m_names[NbCounters];
  };
#endif
  MeshRefinement(DynamicMesh* mesh);
 
 private:
 
  // The copy constructor and assignment operator are
  // declared private but not implemented. This is the
  // standard technique to prevent them from being used.
  MeshRefinement(const MeshRefinement&);
  MeshRefinement& operator=(const MeshRefinement&);
 
 public:

  ~MeshRefinement();

  void clear();
  void init();
 
  void update();
  bool needUpdate() const
  {
    return m_need_update;
  }
  void invalidate()
  {
    m_need_update = true;
  }
  void initMeshContainingBox();
  void flagItems(const Int32Array& flag_per_cell,
                 const Integer max_level = -1);

  virtual void flagCellToRefine(Int32ConstArrayView cells_lids);
  virtual void flagCellToCoarsen(Int32ConstArrayView cells_lids);

  bool refineAndCoarsenItems(const bool maintain_level_one = true);

  bool coarsenItems(const bool maintain_level_one = true);

  bool coarsenItemsV2(bool update_parent_flag);

  bool refineItems(const bool maintain_level_one = true);

  void uniformlyRefine(Integer n = 1);

  void uniformlyCoarsen(Integer n = 1);

  Integer& maxLevel();

  const IMesh* getMesh() const;

  IMesh* getMesh();

  void registerCallBack(IAMRTransportFunctor* f);
  void unRegisterCallBack(IAMRTransportFunctor* f);
  Int64 findOrAddNodeUid(const Real3& p, const Real& tol);
  Int64 findOrAddFaceUid(const Real3& face_center, const Real& tol, bool& is_added);
  Int64 getFirstChildNewUid();
 
  void _update(ArrayView<ItemInternal*> cells_to_refine);
  void _update(ArrayView<Int64> cells_to_refine);
  void _invalidate(ArrayView<ItemInternal*> cells_to_coarsen);
  void _updateMaxUid(ArrayView<ItemInternal*> cells_to_refine);

  template <int typeID> const ItemRefinementPatternT<typeID>& getRefinementPattern() const;
  void populateBackFrontCellsFromChildrenFaces(Cell parent_cell);
  void populateBackFrontCellsFromParentFaces(Cell parent_cell);
 
 private:

  bool _checkLevelOne(bool arcane_assert_yes = false);

  bool _checkUnflagged(bool arcane_assert_yes = false);

  bool& coarsenByParents();

  unsigned char& faceLevelMismatchLimit();

  bool _contract();

  void _interpolateData(const Int64Array& cells_to_refine);

  void _upscaleData(Array<ItemInternal*>& parent_cells);
 
 private:

  bool _coarsenItems();

  bool _refineItems(Int64Array& cells_to_refine);
 
  // Updates the owners of items from the cells
  void _updateItemOwner(Int32ArrayView cell_to_remove);
  void _updateItemOwner2();
  bool _removeGhostChildren();
  //---------------------------------------------
  // Utility algorithms

  void _updateLocalityMap();
  void _updateLocalityMap2();
  void _cleanRefinementFlags();

  bool _makeCoarseningCompatible(const bool);

  bool _makeRefinementCompatible(const bool);

  bool _makeFlagParallelConsistent();
  bool _makeFlagParallelConsistent2();

  template <int typeID>
  void _populateBackFrontCellsFromParentFaces(Cell parent_cell);
  template <int typeID>
  void _populateBackFrontCellsFromChildrenFaces(Face face, Cell parent_cell,
                                                Cell neighbor_cell);
 
  void _checkOwner(const String& msg); // To avoid owner desynchronization
 
 private:

  DynamicMesh* m_mesh;
  FaceFamily* m_face_family;
  bool m_need_update;

  MapCoordToUid::Box m_mesh_containing_box;
  NodeMapCoordToUid m_node_finder;
  FaceMapCoordToUid m_face_finder;

  ItemRefinement* m_item_refinement;

  ParallelAMRConsistency* m_parallel_amr_consistency;

  AMRCallBackMng* m_call_back_mng;

 
  bool m_coarsen_by_parents;
  Integer m_max_level;
  Integer m_nb_cell_target;
  Byte m_face_level_mismatch_limit;
 
  Int64 m_max_node_uid;
  Int64 m_next_node_uid;
 
  Int64 m_max_cell_uid;
  Int64 m_next_cell_uid;
 
  Int64 m_max_face_uid;
  Int64 m_next_face_uid;
 
  Integer m_max_nb_hChildren;

  const Quad4RefinementPattern4Quad m_quad4_refinement_pattern;
  const TetraRefinementPattern2Hex_2Penta_2Py_2Tetra m_tetra_refinement_pattern;
  const PyramidRefinementPattern4Hex_4Py m_pyramid_refinement_pattern;
  const PrismRefinementPattern4Hex_4Pr m_prism_refinement_pattern;
  const HexRefinementPattern8Hex m_hex_refinement_pattern;
  const HemiHex7RefinementPattern6Hex_2HHex7 m_hemihexa7_refinement_pattern;
  const HemiHex6RefinementPattern4Hex_4HHex7 m_hemihexa6_refinement_pattern;
  const HemiHex5RefinementPattern2Hex_4Penta_2HHex5 m_hemihexa5_refinement_pattern;
  const AntiWedgeLeft6RefinementPattern4Hex_4HHex7 m_antiwedgeleft6_refinement_pattern;
  const AntiWedgeRight6RefinementPattern4Hex_4HHex7 m_antiwedgeright6_refinement_pattern;
  const DiTetra5RefinementPattern2Hex_6HHex7 m_ditetra5_refinement_pattern;
 
  // Node owner memory : to patch owner desynchronization
  VariableNodeInt32 m_node_owner_memory;
 
#ifdef ACTIVATE_PERF_COUNTER
  PerfCounterMng<PerfCounter> m_perf_counter;
#endif
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// MeshRefinement class inline members
 
inline bool& MeshRefinement::coarsenByParents()
{
  return m_coarsen_by_parents;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Integer& MeshRefinement::maxLevel()
{
  return m_max_level;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline unsigned char& MeshRefinement::faceLevelMismatchLimit()
{
  return m_face_level_mismatch_limit;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <>
inline const ItemRefinementPatternT<IT_Quad4>&
MeshRefinement::getRefinementPattern<IT_Quad4>() const
{
  return m_quad4_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_Tetraedron4>&
MeshRefinement::getRefinementPattern<IT_Tetraedron4>() const
{
  return m_tetra_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_Pyramid5>&
MeshRefinement::getRefinementPattern<IT_Pyramid5>() const
{
  return m_pyramid_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_Pentaedron6>&
MeshRefinement::getRefinementPattern<IT_Pentaedron6>() const
{
  return m_prism_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_Hexaedron8>&
MeshRefinement::getRefinementPattern<IT_Hexaedron8>() const
{
  return m_hex_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_HemiHexa7>&
MeshRefinement::getRefinementPattern<IT_HemiHexa7>() const
{
  return m_hemihexa7_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_HemiHexa6>&
MeshRefinement::getRefinementPattern<IT_HemiHexa6>() const
{
  return m_hemihexa6_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_HemiHexa5>&
MeshRefinement::getRefinementPattern<IT_HemiHexa5>() const
{
  return m_hemihexa5_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_AntiWedgeLeft6>&
MeshRefinement::getRefinementPattern<IT_AntiWedgeLeft6>() const
{
  return m_antiwedgeleft6_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_AntiWedgeRight6>&
MeshRefinement::getRefinementPattern<IT_AntiWedgeRight6>() const
{
  return m_antiwedgeright6_refinement_pattern;
}
template <>
inline const ItemRefinementPatternT<IT_DiTetra5>&
MeshRefinement::getRefinementPattern<IT_DiTetra5>() const
{
  return m_ditetra5_refinement_pattern;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif