MeshRefinement.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshRefinement.h                                            (C) 2000-2024 */
/*                                                                           */
/* Gestion de l'adaptation de maillages non-structurés par raffinement       */
/*---------------------------------------------------------------------------*/
#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::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:
  // le ctor de copie et l'opérateur d'affectation sont
  // déclarés privés mais non implémentés.  C'est la
  // technique standard pour les empêcher d'être utilisés.
  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);
 
  // mise a jour des owner des items a partir des mailles
  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 // end ARCANE_MESH_MESHREFINEMENT_H
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/