ParallelAMRConsistency.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ParallelAMRConsistency.h                                    (C) 2000-2024 */
/*                                                                           */
/* Management of AMR consistency in parallel.                                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MESH_PARALLELAMRCONSISTENCY_H
#define ARCANE_MESH_PARALLELAMRCONSISTENCY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/String.h"
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/Real3.h"
 
#include "arcane/core/IMesh.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/Item.h"
#include "arcane/core/VariableTypes.h"
 
#include "arcane/mesh/DynamicMeshKindInfos.h"
 
#include "arcane/utils/PerfCounterMng.h"
 
#include <unordered_set>
#include <unordered_map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class FaceInfoMng
{
 public:
 
  Integer size() const
  {
    return m_nodes_unique_id.size();
  }
  void add(ItemUniqueId node_unique_id)
  {
    m_nodes_unique_id.add(node_unique_id);
  }
  void set(Integer i, ItemUniqueId node_unique_id)
  {
    m_nodes_unique_id[i] = node_unique_id;
  }
 
 public:
 
  SharedArray<ItemUniqueId> m_nodes_unique_id;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class NodeInfo
{
 public:
 
  NodeInfo()
  : m_unique_id(NULL_ITEM_ID)
  , m_owner(A_NULL_RANK)
  {
  }
  NodeInfo(ItemUniqueId node_uid, Integer aowner)
  : m_unique_id(node_uid)
  , m_owner(aowner)
  {
  }
 
 public:
 
  ItemUniqueId uniqueId() const
  {
    return m_unique_id;
  }
  void addConnectedFace(ItemUniqueId uid)
  {
    for (Integer i = 0, is = m_connected_active_faces.size(); i < is; ++i)
      if (m_connected_active_faces[i] == uid)
        return;
    m_connected_active_faces.add(uid);
  }
  void setCoord(Real3 coord)
  {
    m_coord = coord;
  }
  Real3 getCoord() const
  {
    return m_coord;
  }
  Integer owner() const
  {
    return m_owner;
  }
 
 private:

  ItemUniqueId m_unique_id;
  Integer m_owner;
  Real3 m_coord;
 
 public:

  SharedArray<ItemUniqueId> m_connected_active_faces;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class FaceInfo
{
 public:
 
  FaceInfo()
  : m_unique_id(NULL_ITEM_ID)
  , m_owner(A_NULL_RANK)
  , m_nb_node(0)
  , m_data_index(-1)
  , m_mng(0)
  {
  }
  FaceInfo(
  ItemUniqueId unique_id,
  ItemUniqueId cell_unique_id,
  Integer nb_node,
  Integer owner,
  Integer data_index,
  FaceInfoMng* mng)
  : m_unique_id(unique_id)
  , m_cell_unique_id(cell_unique_id)
  , m_owner(owner)
  , m_nb_node(nb_node)
  , m_data_index(data_index)
  , m_mng(mng)
  {
  }
 
 public:
 
  ItemUniqueId uniqueId() const
  {
    return m_unique_id;
  }
  ItemUniqueId cellUniqueId() const
  {
    return m_cell_unique_id;
  }
  Integer nbNode() const
  {
    return m_nb_node;
  }
  ItemUniqueId nodeUniqueId(Integer i) const
  {
    return m_mng->m_nodes_unique_id[m_data_index + i];
  }
  void setNodeUniqueId(Integer i, const ItemUniqueId& uid)
  {
    m_mng->m_nodes_unique_id[m_data_index + i] = uid;
  }
  Integer owner() const
  {
    return m_owner;
  }
  void setCenter(Real3 center)
  {
    m_center = center;
  }
  Real3 center() const
  {
    return m_center;
  }
  Integer getDataIndex()
  {
    return m_data_index;
  }
 
 private:
 
  ItemUniqueId m_unique_id;
  ItemUniqueId m_cell_unique_id;
  Integer m_owner;
  Integer m_nb_node;
  Real3 m_center;
 
 public:
 
  Integer m_data_index;
  FaceInfoMng* m_mng;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class FaceInfo2
{
 public:
 
  FaceInfo2()
  : m_unique_id(NULL_ITEM_ID)
  , m_owner(A_NULL_RANK)
  {}
  FaceInfo2(ItemUniqueId unique_id, Integer aowner)
  : m_unique_id(unique_id)
  , m_owner(aowner)
  {}
 
 public:
 
  ItemUniqueId uniqueId() const
  {
    return m_unique_id;
  }
  Integer owner() const
  {
    return m_owner;
  }
  void setCenter(Real3 center)
  {
    m_center = center;
  }
  Real3 center() const
  {
    return m_center;
  }
 
 private:
 
  ItemUniqueId m_unique_id;
  Int32 m_owner;
  Real3 m_center;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ParallelAMRConsistency
: public TraceAccessor
{
 public:
 
  typedef HashTableMapT<ItemUniqueId, NodeInfo> NodeInfoList;
  typedef HashTableMapT<ItemUniqueId, FaceInfo> FaceInfoMap;
  typedef HashTableMapT<ItemUniqueId, FaceInfo2> FaceInfoMap2;
  typedef HashTableMapEnumeratorT<ItemUniqueId, NodeInfo> NodeInfoListEnumerator;
  typedef HashTableMapEnumeratorT<ItemUniqueId, FaceInfo2> FaceInfo2MapEnumerator;
 
  typedef std::unordered_set<Int64> ItemUidSet;
  typedef std::unordered_map<Int64, Item> ItemMap;
  typedef std::pair<Int64, Item> ItemMapValue;
 
#ifdef ACTIVATE_PERF_COUNTER
  struct PerfCounter
  {
    typedef enum
    {
      INIT,
      COMPUTE,
      GATHERFACE,
      UPDATE,
      REHASH,
      ENDUPDATE,
      NbCounters
    } eType;
 
    static const std::string m_names[NbCounters];
  };
#endif
 public:
 
  ParallelAMRConsistency(IMesh* mesh);
 
 public:
 
  void init();
  void invalidate();
  bool isUpdated() const
  {
    return m_is_updated;
  }
  void update()
  {
    if (!m_is_updated)
      init();
  }
  void makeNewItemsConsistent(NodeMapCoordToUid& node_finder, FaceMapCoordToUid& face_finder);
  void makeNewItemsConsistent2(MapCoordToUid& node_finder, MapCoordToUid& face_finder);
  void changeOwners(Int64UniqueArray linked_cells, Int32UniqueArray linked_owers);
  void changeOwnersOld();
 
#ifdef ACTIVATE_PERF_COUNTER
  PerfCounterMng<PerfCounter>& getPerfCounter()
  {
    return m_perf_counter;
  }
#endif
 private:
 
  IMesh* m_mesh;
  VariableNodeReal3 m_nodes_coord;
  FaceInfoMng m_face_info_mng;
  NodeInfoList m_nodes_info;
  NodeInfoList m_active_nodes;
  FaceInfoMap m_active_faces;
  FaceInfoMap2 m_active_faces2;
  String m_active_face_name;
  FaceGroup m_active_face_group;
 
  bool m_is_updated;
  UniqueArray<Int64> m_shared_face_uids;
  UniqueArray<Int64> m_connected_shared_face_uids;
 
#ifdef ACTIVATE_PERF_COUNTER
  PerfCounterMng<PerfCounter> m_perf_counter;
#endif
 private:
 
  bool _isInsideFace(const FaceInfo& face, Real3 point);
 
  void _gatherFaces(ConstArrayView<ItemUniqueId> faces_to_send,
                    ConstArrayView<ItemUniqueId> nodes_to_send,
                    FaceInfoMap& face_map,
                    MapCoordToUid& node_finder,
                    MapCoordToUid& face_finder,
                    ItemUidSet& updated_face_uids,
                    ItemUidSet& updated_node_uids);
 
  void _update(Array<ItemUniqueId>& nodes_unique_id, NodeInfoList const& nodes_info);
 
  void _gatherItems(ConstArrayView<ItemUniqueId> nodes_to_send,
                    ConstArrayView<ItemUniqueId> faces_to_send,
                    NodeInfoList& node_map,
                    FaceInfoMap2& face_map,
                    MapCoordToUid& node_finder,
                    MapCoordToUid& face_finder);
 
  void _gatherAllNodesInfo();
 
  void _printFaces(std::ostream& o, FaceInfoMap& face_map);
 
  void _addFaceToList(Face face, FaceInfoMap& face_map);
 
  void _addFaceToList2(Face face, FaceInfoMap2& face_map);
  void _addNodeToList(Node node, NodeInfoList& node_map);
  bool _hasSharedNodes(Face face);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif