d0/d05/ParallelAMRConsistency_8cc_source.html

// -*- 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

//-----------------------------------------------------------------------------

/*---------------------------------------------------------------------------*/

/*  ParallelAMRConsistency.cc                                  (C) 2000-2024 */

/*                                                                           */

/* Consistence parallèle des uid des noeuds/faces dans le cas AMR            */

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#include "arcane/utils/HashTableMap.h"

#include "arcane/utils/Real3.h"

#include "arcane/utils/NotImplementedException.h"

#include "arcane/utils/PlatformUtils.h"

#include "arcane/utils/ITraceMng.h"

#include "arcane/utils/Collection.h"


#include "arcane/mesh/DynamicMesh.h"

#include "arcane/mesh/FaceFamily.h"

#include "arcane/mesh/MapCoordToUid.h"

#include "arcane/mesh/ParallelAMRConsistency.h"


#include "arcane/core/IMesh.h"

#include "arcane/core/IMeshSubMeshTransition.h"

#include "arcane/core/ItemEnumerator.h"

#include "arcane/core/ItemGroup.h"

#include "arcane/core/Item.h"

#include "arcane/core/ISubDomain.h"

#include "arcane/core/VariableTypes.h"

#include "arcane/core/IItemFamily.h"

#include "arcane/core/ItemCompare.h"

#include "arcane/core/IParallelMng.h"

#include "arcane/core/GeometricUtilities.h"

#include "arcane/core/SerializeBuffer.h"

#include "arcane/core/ItemPrinter.h"

#include "arcane/core/IMeshUtilities.h"


#include <set>


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane::mesh

{


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#ifdef ACTIVATE_PERF_COUNTER

const std::string ParallelAMRConsistency::PerfCounter::m_names[ParallelAMRConsistency::PerfCounter::NbCounters] =

  {

    "INIT",

    "COMPUTE",

    "GATHERFACE",

    "UPDATE",

    "REHASH",

    "ENDUPDATE"

  };

#endif


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


ParallelAMRConsistency::

ParallelAMRConsistency(IMesh* mesh)

: TraceAccessor(mesh->traceMng())

, m_mesh(mesh)

, m_nodes_coord(m_mesh->toPrimaryMesh()->nodesCoordinates())

, m_nodes_info(1000, true)

, m_active_nodes(1000, true)

, m_active_faces(5000, true)

, m_active_faces2(5000, true)

, m_is_updated(false)

{

  ;

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

init()

{

  CHECKPERF( m_perf_counter.start(PerfCounter::INIT) )

  // Marque les noeuds sur la frontière

  Integer nb_active_face = static_cast<Integer> (m_mesh->nbFace() * 0.2); // 20% de faces shared (sur estimé)

  m_shared_face_uids.reserve(nb_active_face) ;

  m_shared_face_uids.clear() ;

  m_connected_shared_face_uids.reserve(nb_active_face) ;

  m_connected_shared_face_uids.clear() ;

  Integer sid = m_mesh->parallelMng()->commRank();

  ENUMERATE_FACE(iface,m_mesh->allFaces()){

    Face face = *iface;

    ItemUniqueId face_uid = face.uniqueId();

    int face_flags = face.itemBase().flags();

    if (face.nbCell()==2 && (face.cell(0).level()==0 && face.cell(1).level()==0)){

      if ( (face.cell(0).owner()!=sid || face.cell(1).owner()!= sid) ||

           (face_flags & ItemFlags::II_Shared) ||

           (face_flags & ItemFlags::II_SubDomainBoundary)){

        m_shared_face_uids.add(face_uid);

      }

      else if (_hasSharedNodes(face)){

        m_connected_shared_face_uids.add(face_uid);

      }

    }

    else if (face.nbCell()==1 && face.cell(0).level() == 0){

      if (_hasSharedNodes(face)){

        m_connected_shared_face_uids.add(face_uid);

      }

    }

  }

  m_is_updated = true ;


  CHECKPERF( m_perf_counter.stop(PerfCounter::INIT) )

}

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_addFaceToList(Face face, FaceInfoMap& face_map)

{

  Integer nb_node = face.nbNode();

  Real3 center(0., 0., 0.);

  Integer data_index = m_face_info_mng.size();

  for (Node node : face.nodes()){

    Real3 node_coord = m_nodes_coord[node];

    ItemUniqueId uid = node.uniqueId();

    m_face_info_mng.add(uid);

    center += node_coord;

  }

  center /= nb_node;

  //info() << "ADD FACE uid=" << face.uniqueId() << " nb_node="

  //<< nb_node << " center=" << center;

  FaceInfo fi(face.uniqueId(), face.cell(0).uniqueId(), nb_node, face.owner(), data_index, &m_face_info_mng);

  fi.setCenter(center);

  face_map.add(face.uniqueId(), fi);

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


bool ParallelAMRConsistency::

_hasSharedNodes(Face face)

{

  //CHECK that one edge is connected to a ghost cell

  for ( Node node : face.nodes() ){

    if (node.itemBase().flags() &  ItemFlags::II_Shared)

      return true;

  }

  return false;

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

makeNewItemsConsistent(NodeMapCoordToUid& node_finder, FaceMapCoordToUid& face_finder)

{

  CHECKPERF( m_perf_counter.start(PerfCounter::COMPUTE) )

  //Integer nb_sub_domain_boundary_face = 0;

  // Marque les noeuds sur la frontière

  Integer nb_active_face = static_cast<Integer> (m_mesh->nbFace() * 0.2); // 20% de faces shared (sur estimé)


  m_nodes_info.resize((nb_active_face * 2) + 5);

  m_nodes_info.clear() ;

  ENUMERATE_NODE(i_item,m_mesh->allNodes()){

    Real3 node_coord = m_nodes_coord[i_item];

    ItemUniqueId uid = i_item->uniqueId();

    NodeInfo node_info(uid, i_item->owner());

    node_info.setCoord(node_coord);

    m_nodes_info.add(uid, node_info);

  }


  m_active_faces.resize((nb_active_face * 2) + 5);

  m_active_nodes.resize((nb_active_face * 2) + 5);

  m_active_faces.clear() ;

  m_face_info_mng.m_nodes_unique_id.clear() ;

  m_face_info_mng.m_nodes_unique_id.reserve(nb_active_face) ;


  FaceFamily* true_face_family = dynamic_cast<FaceFamily*> (m_mesh->faceFamily());

  if (!true_face_family)

    ARCANE_FATAL("can not obtain FaceFamily");


  Int32 sid = m_mesh->parallelMng()->commRank();

  //UniqueArray<ItemInternal*> active_faces;

  ItemMap active_faces ;

  UniqueArray < ItemUniqueId > active_faces_to_send;

  typedef std::set<ItemInternal*> Set;

  Set active_nodes_set;

  ItemMap active_nodes ;

  // Parcours les faces et marque les noeuds frontieres actives

  DynamicMesh* mesh = dynamic_cast<DynamicMesh*> (m_mesh);

  if (!mesh)

    throw FatalErrorException(A_FUNCINFO, "can not obtain DynamicMesh");

  ItemInternalMap& faces_map = mesh->facesMap();


  for(Integer iface=0;iface<m_shared_face_uids.size();++iface){

    Int64 face_uid = m_shared_face_uids[iface];

    Face face = faces_map.findItem(face_uid);

    {

      UniqueArray<ItemInternal*> subfaces;

      true_face_family->allSubFaces(face, subfaces);

      if (subfaces.size() != 1){

        for (Integer s = 0; s < subfaces.size(); s++){

          Face face2 = subfaces[s];

          face2.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

          Int64 uid = face2.uniqueId() ;

          bool face_to_send = face_finder.isNewUid(uid);

          if(face_to_send){

            _addFaceToList(face2, m_active_faces);


            //active_faces.add(face2);

            active_faces.insert(ItemMapValue(uid,face2));

            active_faces_to_send.add(ItemUniqueId(uid));

            for ( Node node : face2.nodes() ){

              node.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

              active_nodes.insert(ItemMapValue(node.uniqueId(),node));

            }

            for ( Edge edge : face2.edges() ){

              edge.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

            }

          }

        }

      }

    }

  }

  for(Integer iface=0;iface<m_connected_shared_face_uids.size();++iface){

    Int64 face_uid = m_connected_shared_face_uids[iface];

    Face face(faces_map.findItem(face_uid));


    {

      Integer nb_node = face.nbNode() ;

      typedef std::pair<Real3,Real3> Edge ;

      UniqueArray<Edge> edges ;

      edges.reserve(nb_node) ;

      for(Integer i=0;i<nb_node;++i){

        Integer next = i==nb_node-1?0:i+1;

        Node node1 = face.node(i) ;

        Node node2 = face.node(next) ;

        if( (node1.itemBase().flags() & (ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary)) &&

            (node2.itemBase().flags() & (ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary) ) ){

          edges.add(Edge(m_nodes_coord[node1],m_nodes_coord[node2]-m_nodes_coord[node1])) ;

        }

      }

      UniqueArray<ItemInternal*> subfaces;

      true_face_family->allSubFaces(face, subfaces);

      for (Integer s = 0; s < subfaces.size(); s++){

        Face face2(subfaces[s]);

        Int64 uid = face2.uniqueId() ;

        bool face_to_send = face_finder.isNewUid(uid) ;

        if (face_to_send){

          Integer nb_node2 = face2.nbNode() ;

          for(Integer i=0;i<nb_node2;++i){

            Node node_i = face2.node(i) ;

            Real3 Xi = m_nodes_coord[node_i] ;

            for(Integer j=0;j<edges.size();++j){

              Real3 n = Xi-edges[j].first ;

              Real sinteta = math::cross(edges[j].second,n).squareNormL2() ;

              if (math::isZero(sinteta)){

                node_i.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

                //active_nodes_set.insert(node_i);

                active_nodes.insert(ItemMapValue(node_i.uniqueId(),node_i));

                _addNodeToList(node_i, m_active_nodes);

              }

            }

          }

        }

      }

    }

  }


  UniqueArray<ItemUniqueId> active_nodes_to_send(arcaneCheckArraySize(active_nodes.size()));

  ItemMap::const_iterator nit(active_nodes.begin()), nend(active_nodes.end());

  for (int i=0; nit != nend; ++nit,++i){

    Item node = nit->second;

    active_nodes_to_send[i]= node.uniqueId();

    //active_nodes.insert(ItemMapValue(uid,node)) ;

  }

  CHECKPERF( m_perf_counter.stop(PerfCounter::COMPUTE) )


  //CHECKPERF( m_perf_counter.start(PerfCounter::GATHERFACE) )

  ItemUidSet update_face_uids ;

  ItemUidSet update_node_uids ;

  _gatherFaces(active_faces_to_send,active_nodes_to_send, m_active_faces, node_finder, face_finder,update_face_uids,update_node_uids);

  //CHECKPERF( m_perf_counter.stop(PerfCounter::GATHERFACE) )


  CHECKPERF( m_perf_counter.start(PerfCounter::UPDATE) )

  //UPDATE FACES

  //for (Integer index = 0; index < active_faces.size(); index++)

  for(ItemUidSet::iterator iter = update_face_uids.begin();iter!=update_face_uids.end();++iter){

    Int64 face_uid = *iter ;

    Item face = active_faces[face_uid];

    //const Int64 current_uid = face->uniqueId();

    FaceInfo& fi = m_active_faces[face.uniqueId()];

    Int64 new_uid = fi.uniqueId() ;

    faces_map.remove(face_uid) ;

    //if (current_uid != fi.uniqueId())

    ARCANE_ASSERT((face_uid != new_uid),("AMR CONSISTENCY UPDATE FACE ERROR")) ;

    face.mutableItemBase().setUniqueId(fi.uniqueId());

    face.mutableItemBase().setOwner(fi.owner(), sid);

    //debug() << "[\t ParallelAMRConsistency] NEW FACE BEFORE " << face->uniqueId()<<" new uid "<<fi.uniqueId() << " " << fi.owner();

    faces_map.add(new_uid,ItemCompatibility::_itemInternal(face));

  }


  //UPDATE NODES

  //ENUMERATE_NODE(i_item,m_mesh->allNodes())

  ItemInternalMap& nodes_map = mesh->nodesMap();

  for(ItemUidSet::iterator iter = update_node_uids.begin();iter!=update_node_uids.end();++iter){

    //ItemInternal* node = i_item->internal() ;

    Int64 node_uid = *iter ;

    Item node = active_nodes[node_uid];

    if (node.null())

      ARCANE_FATAL("AMR CONSISTENCY NULL NODE ERROR");

    //const Int64 node_uid = node->uniqueId();

    NodeInfo ni = m_nodes_info[node.uniqueId()];

    Int64 new_uid = ni.uniqueId() ;

    //if (node_uid != ni.uniqueId())

    ARCANE_ASSERT((node_uid != new_uid),("AMR CONSISTENCY UPDATE NODE ERROR")) ;

    //debug() << "[\t ParallelAMRConsistency] OLD NEW NODE " << node_uid << " " << ni.uniqueId()<<" owner "<<ni.owner();

    nodes_map.remove(node_uid) ;

    node.mutableItemBase().setUniqueId(ni.uniqueId());

    node.mutableItemBase().setOwner(ni.owner(), sid);

    node.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

    nodes_map.add(new_uid,ItemCompatibility::_itemInternal(node));

  }

  CHECKPERF( m_perf_counter.stop(PerfCounter::UPDATE) )


  CHECKPERF( m_perf_counter.start(PerfCounter::ENDUPDATE) )

  m_mesh->nodeFamily()->partialEndUpdate();

  m_mesh->faceFamily()->partialEndUpdate();

  CHECKPERF( m_perf_counter.stop(PerfCounter::ENDUPDATE) )

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_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)

{

  CHECKPERF( m_perf_counter.start(PerfCounter::GATHERFACE) )


  IParallelMng* pm = m_mesh->parallelMng();

  Integer sub_domain_id = pm->commRank();

  Integer nb_sub_domain = pm->commSize();


  const Real tol = 10e-12;


  SerializeBuffer sbuf;

  sbuf.setMode(ISerializer::ModeReserve);

  Integer nb_to_send = faces_to_send.size();

  Integer nb_node_to_send = nodes_to_send.size();


  Int64UniqueArray unique_ids(nb_to_send);

  Int64UniqueArray cells_unique_ids(nb_to_send);

  Int64UniqueArray nodes_unique_id;

  nodes_unique_id.reserve(nb_node_to_send);

  RealUniqueArray coords;

  coords.reserve(3 * nb_to_send);

  RealUniqueArray nodes_coords;

  nodes_coords.reserve(3 *nb_node_to_send );

  for (Integer i = 0; i < nb_to_send; ++i){

    const FaceInfo& fi = face_map[faces_to_send[i]];

    unique_ids[i] = fi.uniqueId().asInt64();

    cells_unique_ids[i] = fi.cellUniqueId().asInt64();

    coords.add(fi.center().x);

    coords.add(fi.center().y);

    coords.add(fi.center().z);

  }

  debug()<<"SEND NODE : "<<nb_node_to_send;

  for (Integer i = 0; i < nb_node_to_send; ++i){

      //debug()<<"SEND NODE : "<<nodes_to_send[i];

      ItemUniqueId nuid(nodes_to_send[i]);

      nodes_unique_id.add(nuid.asInt64());

      NodeInfo ni = m_nodes_info[nuid];

      Real3 c = ni.getCoord();

      nodes_coords.add(c.x);

      nodes_coords.add(c.y);

      nodes_coords.add(c.z);

  }

  sbuf.reserveInteger(1); // pour le nombre de faces

  sbuf.reserveInteger(1); // pour le numéro du sous-domaine

  sbuf.reserveInteger(1); // pour le nombre de noeuds dans la liste

  sbuf.reserveArray(unique_ids); // pour le unique id des faces

  sbuf.reserveArray(cells_unique_ids); // pour le unique id des mailles des faces

  sbuf.reserveArray(nodes_unique_id); // pour la liste des noeuds

  sbuf.reserveArray(coords); // pour les coordonnées du centre

  sbuf.reserveArray(nodes_coords); // pour les coordonnées des noeuds


  sbuf.allocateBuffer();

  sbuf.setMode(ISerializer::ModePut);


  sbuf.putInteger(nb_to_send);

  sbuf.putInteger(sub_domain_id);

  sbuf.putInteger(nodes_unique_id.size());

  sbuf.putArray(unique_ids);

  sbuf.putArray(cells_unique_ids);

  sbuf.putArray(nodes_unique_id);

  sbuf.putArray(coords);

  sbuf.putArray(nodes_coords);


  SerializeBuffer recv_buf;

  pm->allGather(&sbuf, &recv_buf);

  recv_buf.setMode(ISerializer::ModeGet);


  for (Integer i = 0; i < nb_sub_domain; ++i){

    Integer nb_face = recv_buf.getInteger();

    Integer sid = recv_buf.getInteger();

    Integer nb_node_unique_id = recv_buf.getInteger();

    info() << " [\t ParallelAMRConsistency::_gatherFaces] READ nface=" << nb_face << " FROM sid=" << sid<<" "<<m_face_info_mng.size();

    recv_buf.getArray(unique_ids);

    recv_buf.getArray(cells_unique_ids);

    recv_buf.getArray(nodes_unique_id);

    recv_buf.getArray(coords);

    recv_buf.getArray(nodes_coords);


    // Parcours toutes les faces reçues si certaines sont absentes,

    // on les ignore.

    for (Integer z = 0; z < nb_face; ++z){

      ItemUniqueId new_uid(unique_ids[z]);

      ItemUniqueId cell_uid(cells_unique_ids[z]);


      Real3 center;

      center.x = coords[z * 3];

      center.y = coords[z * 3 + 1];

      center.z = coords[z * 3 + 2];


      const Int64 current_uid = face_finder.find(center, tol);

      if ((current_uid != NULL_ITEM_ID) && (new_uid < current_uid)){

        if (!face_map.hasKey(ItemUniqueId(current_uid))){

          error() << "face uid not found \n";

        }

        //UPDATE FACE_FINDER

        face_finder.insert(center,new_uid,tol) ;

        updated_face_uids.insert(current_uid) ;


        FaceInfo& fi_old = face_map[ItemUniqueId(current_uid)];

        Integer data_index = fi_old.getDataIndex();

        Integer nb_node = fi_old.nbNode() ;

        FaceInfo fi(new_uid, cell_uid, nb_node, sid, data_index, &m_face_info_mng);

        fi.setCenter(center);

        face_map[ItemUniqueId(current_uid)] = fi;

      }

    }


    for (Integer z = 0; z < nb_node_unique_id; ++z){

      ItemUniqueId nuid(nodes_unique_id[z]);

      Real3 node_coord;

      node_coord.x = nodes_coords[z * 3];

      node_coord.y = nodes_coords[z * 3 + 1];

      node_coord.z = nodes_coords[z * 3 + 2];

      Int64 current_node_uid = node_finder.find(node_coord, tol);

      if ((current_node_uid != NULL_ITEM_ID) && (nuid < current_node_uid)){

        ItemUniqueId c_nuid(current_node_uid);

        if(nuid<m_nodes_info[c_nuid].uniqueId()){

          NodeInfo ni(nuid, sid);

          ni.setCoord(node_coord);

          m_nodes_info[c_nuid] = ni;


          // UPDATE NODE FINDER

          updated_node_uids.insert(current_node_uid) ;

        }

      }

    }

  }

  CHECKPERF( m_perf_counter.stop(PerfCounter::GATHERFACE) )


  CHECKPERF( m_perf_counter.start(PerfCounter::UPDATE) )

  //update node_finder

  for(ItemUidSet::iterator iter = updated_node_uids.begin();iter!=updated_node_uids.end();++iter){

    ItemUniqueId uid(*iter);

    NodeInfo& ni = m_nodes_info[uid] ;

    node_finder.insert(ni.getCoord(),ni.uniqueId(),tol) ;

  }


  //update m_face_info_mng

  _update(m_face_info_mng.m_nodes_unique_id,m_nodes_info) ;


  CHECKPERF( m_perf_counter.stop(PerfCounter::UPDATE) )


  //pm->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_update(Array<ItemUniqueId>& nodes_unique_id, NodeInfoList const& nodes_info)

{

  for(Integer i=0, n=nodes_unique_id.size();i<n;++i)

  {

    ItemUniqueId& uid = nodes_unique_id[i] ;

    NodeInfoList::Data const* data = nodes_info.lookup(uid);

    if (data)

      nodes_unique_id[i] = data->value().uniqueId() ;

    else

      info()<<"ERROR "<<i<<" "<<uid<<" not found";

  }

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_addNodeToList(Node node, NodeInfoList& node_map)

{

  Real3 node_coord = m_nodes_coord[node];

  ItemUniqueId uid = node.uniqueId();

  NodeInfoList::Data* i = node_map.lookup(uid);

  if (!i){

    NodeInfo node_info(uid, node.owner());

    node_info.setCoord(node_coord);

    node_map.add(uid, node_info);

  }

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_addFaceToList2(Face face, FaceInfoMap2& face_map)

{

  Integer nb_node = face.nbNode();

  ItemUniqueId uid = face.uniqueId();

  FaceInfoMap2::Data* i = face_map.lookup(uid);

  if (!i){

    Real3 center(0., 0., 0.);

    for (Node node : face.nodes() ){

      Real3 node_coord = m_nodes_coord[node];

      center += node_coord;

    }

    center /= nb_node;

    FaceInfo2 fi(face.uniqueId(), face.owner());

    fi.setCenter(center);

    face_map.add(uid, fi);

  }

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

makeNewItemsConsistent2(MapCoordToUid& node_finder, MapCoordToUid& face_finder)

{

  // Marque les noeuds sur la frontière

  Integer nb_active_face = static_cast<Integer> (m_mesh->nbFace() * 0.2); // 20% de faces shared (sur estimé)

  m_active_nodes.resize((nb_active_face * 2) + 5);

  m_active_faces.resize((nb_active_face * 2) + 5);


  FaceFamily* true_face_family = dynamic_cast<FaceFamily*> (m_mesh->itemFamily(IK_Face));

  if (!true_face_family)

    throw FatalErrorException(A_FUNCINFO, "can not obtain FaceFamily");


  Int32 sid = m_mesh->parallelMng()->commRank();


  typedef std::set<Item> Set;

  Set active_nodes_set, active_faces_set;

  // Parcours les faces et marque les noeuds frontieres actives

  DynamicMesh* mesh = dynamic_cast<DynamicMesh*> (m_mesh);

  if (!mesh)

    throw FatalErrorException(A_FUNCINFO, "can not obtain DynamicMesh");

  ItemInternalMap& faces_map = mesh->facesMap();


  faces_map.eachItem([&](Face face) {

    bool is_sub_domain_boundary_face = false;

    if (face.itemBase().flags() & ItemFlags::II_SubDomainBoundary){

      is_sub_domain_boundary_face = true; // true is not needed

    }

    else{

      if (face.cell(0).level() == 0 && face.cell(1).level() == 0){

        if ((face.cell(0).owner() != sid || face.cell(1).owner() != sid))

          is_sub_domain_boundary_face = true;

      }

    }


    if (is_sub_domain_boundary_face){

      UniqueArray<ItemInternal*> subfaces;

      true_face_family->allSubFaces(face, subfaces);

      for (Integer s = 0; s < subfaces.size(); s++){

        Face face2 = subfaces[s];

        face2.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

        _addFaceToList2(face2, m_active_faces2);

        active_faces_set.insert(face2);

        for ( Node node : face2.nodes() ){

          node.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

          active_nodes_set.insert(node);

          _addNodeToList(node, m_active_nodes);

        }

        for ( Edge edge : face2.edges() )

          edge.mutableItemBase().addFlags(ItemFlags::II_Shared | ItemFlags::II_SubDomainBoundary);

      }

    }

  });


  UniqueArray<ItemUniqueId> active_faces_to_send(arcaneCheckArraySize(active_faces_set.size()));

  UniqueArray<ItemUniqueId> active_nodes_to_send(arcaneCheckArraySize(active_nodes_set.size()));


  UniqueArray<Item> active_faces(arcaneCheckArraySize(active_faces_set.size()));

  UniqueArray<Item> active_nodes(arcaneCheckArraySize(active_nodes_set.size()));


  Set::const_iterator fit(active_faces_set.begin()), fend(active_faces_set.end());

  Integer i=0;

  for (; fit != fend; ++fit){

    Item face = *fit;

    active_faces_to_send[i]=(face.uniqueId());

    active_faces[i]=face;

    i++;

  }

  Set::const_iterator nit(active_nodes_set.begin()), nend(active_nodes_set.end());

  i=0;

  for (; nit != nend; ++nit){

    Item node = *nit;

    active_nodes_to_send[i]= (node.uniqueId());

    //debug() << "ACTIVE NODE TO SEND " << node->uniqueId() << " " << active_nodes_to_send[i];

    active_nodes[i]=node;

    i++;

  }


  _gatherItems(active_nodes_to_send, active_faces_to_send, m_active_nodes, m_active_faces2, node_finder, face_finder);


  for (Integer index = 0; index < active_faces.size(); index++){

    Item face = active_faces[index];

    const Int64 current_uid = face.uniqueId();

    FaceInfo2& fi = m_active_faces2[face.uniqueId()];

    if (current_uid != fi.uniqueId()){

      face.mutableItemBase().setUniqueId(fi.uniqueId());

      face.mutableItemBase().setOwner(fi.owner(), sid);

      //debug() << "[\t ParallelAMRConsistency] NEW FACE BEFORE " << fi.uniqueId() << " " << fi.owner();

    }

  }

  for (Integer index = 0; index < active_nodes.size(); index++){

    Item node = active_nodes[index];

    const Int64 current_uid = node.uniqueId();

    NodeInfo& ni = m_active_nodes[node.uniqueId()];

    if (current_uid != ni.uniqueId()){

      node.mutableItemBase().setUniqueId(ni.uniqueId());

      node.mutableItemBase().setOwner(ni.owner(), sid);

      //debug() << "[\t ParallelAMRConsistency] NEW FACE BEFORE " << fi.uniqueId() << " " << fi.owner();

    }

  }


  // Il faut ranger à nouveau #m_faces_map car les uniqueId() des

  // faces ont été modifiés

  faces_map.notifyUniqueIdsChanged();

  // idem pour les noeuds

  mesh->nodesMap().notifyUniqueIdsChanged();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void ParallelAMRConsistency::

_gatherItems(ConstArrayView<ItemUniqueId> nodes_to_send,

             ConstArrayView<ItemUniqueId> faces_to_send,

             NodeInfoList& node_map,

             FaceInfoMap2& face_map,

             MapCoordToUid& node_finder,

             MapCoordToUid& face_finder)

{

  IParallelMng* pm = m_mesh->parallelMng();

  Integer sub_domain_id = pm->commRank();

  Integer nb_sub_domain = pm->commSize();


  SerializeBuffer sbuf;

  sbuf.setMode(ISerializer::ModeReserve);

  Integer nb_to_send = faces_to_send.size();

  Integer nb_node_to_send = nodes_to_send.size();

  Int64UniqueArray unique_ids(nb_to_send);

  Int64UniqueArray node_unique_ids(nb_node_to_send);

  RealUniqueArray coords;

  coords.reserve(3 * nb_to_send);

  RealUniqueArray nodes_coords;

  nodes_coords.reserve(3 * nb_node_to_send);


  for (Integer i = 0; i < nb_node_to_send; ++i){

    const NodeInfo& ni = node_map[nodes_to_send[i]];

    node_unique_ids[i] = ni.uniqueId().asInt64();

    const Real3 c = ni.getCoord();

    nodes_coords.add(c.x);

    nodes_coords.add(c.y);

    nodes_coords.add(c.z);

  }


  for (Integer i = 0; i < nb_to_send; ++i){

    const FaceInfo2& fi = face_map[faces_to_send[i]];

    unique_ids[i] = fi.uniqueId().asInt64();

    coords.add(fi.center().x);

    coords.add(fi.center().y);

    coords.add(fi.center().z);

  }


  sbuf.reserveInteger(1); // pour le nombre de faces

  sbuf.reserveInteger(1); // pour le numéro du sous-domaine

  sbuf.reserveInteger(1); // pour le nombre de noeuds dans la liste

  sbuf.reserveArray(unique_ids); // pour le unique id des faces

  sbuf.reserveArray(node_unique_ids); // pour la liste des noeuds

  sbuf.reserveArray(coords); // pour les coordonnées du centre

  sbuf.reserveArray(nodes_coords); // pour les coordonnées des noeuds


  sbuf.allocateBuffer();

  sbuf.setMode(ISerializer::ModePut);


  sbuf.putInteger(nb_to_send);

  sbuf.putInteger(sub_domain_id);

  sbuf.putInteger(node_unique_ids.size());

  sbuf.putArray(unique_ids);

  sbuf.putArray(node_unique_ids);

  sbuf.putArray(coords);

  sbuf.putArray(nodes_coords);


  SerializeBuffer recv_buf;

  pm->allGather(&sbuf, &recv_buf);

  recv_buf.setMode(ISerializer::ModeGet);


  for (Integer i = 0; i < nb_sub_domain; ++i){

    Integer nb_face = recv_buf.getInteger();

    Integer sid = recv_buf.getInteger();

    Integer nb_node_unique_id = recv_buf.getInteger();

    //info() << " [\t ParallelAMRConsistency::_gatherFaces] READ nface=" << nb_face << " FROM sid=" << sid;


    recv_buf.getArray(unique_ids);

    recv_buf.getArray(node_unique_ids);

    recv_buf.getArray(coords);

    recv_buf.getArray(nodes_coords);


    // Parcours toutes les faces reçues si certaines sont absentes,

    // on les ignore.

    const Real tol = 10e-6;

    for (Integer z = 0; z < nb_face; ++z){

      ItemUniqueId new_uid(unique_ids[z]);


      Real3 center;

      center.x = coords[z * 3];

      center.y = coords[z * 3 + 1];

      center.z = coords[z * 3 + 2];


      const Int64 current_uid = face_finder.find(center, tol);

      if ((current_uid != NULL_ITEM_ID) && (new_uid < current_uid)){

        if (!face_map.hasKey(ItemUniqueId(current_uid))){

          error() << "face uid not found \n";

        }

        FaceInfo2 fi(new_uid, sid);

        fi.setCenter(center);

        face_map[ItemUniqueId(current_uid)] = fi;

      }

    }


    for (Integer z = 0; z < nb_node_unique_id; ++z){

      ItemUniqueId nuid(node_unique_ids[z]);

      Real3 node_coord;

      node_coord.x = nodes_coords[z * 3];

      node_coord.y = nodes_coords[z * 3 + 1];

      node_coord.z = nodes_coords[z * 3 + 2];

      Int64 current_node_uid = node_finder.find(node_coord, tol);

      if ((current_node_uid != NULL_ITEM_ID) && (nuid < current_node_uid)){

        NodeInfo ni(nuid, sid);

        ni.setCoord(node_coord);

        ItemUniqueId c_nuid(current_node_uid);

        node_map[c_nuid] = ni;

      }

    }

  }

  pm->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


} // End namespace Arcane::mesh


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809

ItemEnumerator.h
Types et macros pour itérer sur les entités du maillage.

ENUMERATE_FACE
#define ENUMERATE_FACE(name, group)
Enumérateur générique d'un groupe de faces.
Definition ItemEnumerator.h:424

ENUMERATE_NODE
#define ENUMERATE_NODE(name, group)
Enumérateur générique d'un groupe de noeuds.
Definition ItemEnumerator.h:418

Arcane::Cell::level
Int32 level() const
Definition Item.h:1328

Arcane::Edge
Arête d'une maille.
Definition Item.h:798

Arcane::Face
Face d'une maille.
Definition Item.h:932

Arcane::Face::cell
Cell cell(Int32 i) const
i-ème maille de la face
Definition Item.h:1617

Arcane::Face::nbCell
Int32 nbCell() const
Nombre de mailles de la face (1 ou 2)
Definition Item.h:1006

Arcane::HashTableMapT< ItemUniqueId, FaceInfo >

Arcane::HashTableMapT::resize
void resize(Integer new_size, bool use_prime=false)
Redimensionne la table de hachage.
Definition HashTableMap.h:360

Arcane::HashTableMapT::add
bool add(KeyTypeConstRef id, const ValueType &value)
Ajoute la valeur value correspondant à la clé id.
Definition HashTableMap.h:262

Arcane::HashTableMapT::clear
void clear()
Supprime tous les éléments de la table.
Definition HashTableMap.h:180

Arcane::IMeshBase::nodeFamily
virtual IItemFamily * nodeFamily()=0
Retourne la famille des noeuds.

Arcane::IMeshBase::allFaces
virtual FaceGroup allFaces()=0
Groupe de toutes les faces.

Arcane::IMeshBase::itemFamily
virtual IItemFamily * itemFamily(eItemKind ik)=0
Retourne la famille d'entité de type ik.

Arcane::IMeshBase::faceFamily
virtual IItemFamily * faceFamily()=0
Retourne la famille des faces.

Arcane::IMeshBase::allNodes
virtual NodeGroup allNodes()=0
Groupe de tous les noeuds.

Arcane::IMeshBase::nbFace
virtual Integer nbFace()=0
Nombre de faces du maillage.

Arcane::IMesh
Definition IMesh.h:59

Arcane::IMesh::parallelMng
virtual IParallelMng * parallelMng()=0
Gestionnaire de parallèlisme.

Arcane::IParallelMng
Interface du gestionnaire de parallélisme pour un sous-domaine.
Definition IParallelMng.h:52

Arcane::IParallelMng::commRank
virtual Int32 commRank() const =0
Rang de cette instance dans le communicateur.

Arcane::IParallelMng::commSize
virtual Int32 commSize() const =0
Nombre d'instance dans le communicateur.

Arcane::IParallelMng::allGather
virtual void allGather(ConstArrayView< char > send_buf, ArrayView< char > recv_buf)=0
Effectue un regroupement sur tous les processeurs. Il s'agit d'une opération collective....

Arcane::IParallelMng::barrier
virtual void barrier()=0
Effectue une barière.

Arcane::ItemBase::flags
Int32 flags() const
Flags de l'entité
Definition ItemInternal.h:484

Arcane::ItemFlags::II_Shared
@ II_Shared
L'entité est partagée par un autre sous-domaine.
Definition ItemFlags.h:51

Arcane::ItemFlags::II_SubDomainBoundary
@ II_SubDomainBoundary
L'entité est à la frontière de deux sous-domaines.
Definition ItemFlags.h:52

Arcane::ItemUniqueId
Identifiant unique d'une entité.
Definition ItemUniqueId.h:35

Arcane::ItemWithNodes::node
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:768

Arcane::ItemWithNodes::nbNode
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:765

Arcane::Item
Classe de base d'un élément de maillage.
Definition Item.h:83

Arcane::Item::mutableItemBase
impl::MutableItemBase mutableItemBase() const
Partie interne modifiable de l'entité.
Definition Item.h:365

Arcane::Item::owner
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:229

Arcane::Item::uniqueId
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:216

Arcane::Item::null
constexpr bool null() const
true si l'entité est nul (i.e. non connecté au maillage)
Definition Item.h:207

Arcane::Item::itemBase
impl::ItemBase itemBase() const
Partie interne de l'entité.
Definition Item.h:354

Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120

Arcane::MutableItemBase::setOwner
void setOwner(Integer suid, Int32 current_sub_domain)
Positionne le numéro du sous-domaine propriétaire de l'entité.
Definition ItemInternal.h:817

Arcane::MutableItemBase::addFlags
void addFlags(Int32 added_flags)
Ajoute les flags \added_flags à ceux de l'entité
Definition ItemInternal.h:832

Arcane::Node
Noeud d'un maillage.
Definition Dom.h:204

Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132

Arcane::Real3::squareNormL2
constexpr ARCCORE_HOST_DEVICE Real squareNormL2() const
Retourne la norme L2 au carré du triplet .
Definition Real3.h:230

Arcane::SerializeBuffer
Implémentation d'un tampon pour la sérialisation.
Definition SerializeBuffer.h:42

Arcane::mesh::DynamicMesh
Implémentation d'un maillage.
Definition DynamicMesh.h:97

Arcane::mesh::FaceFamily
Famille de faces.
Definition FaceFamily.h:53

Arcane::mesh::FaceInfo2
Infos sur une Face active.
Definition ParallelAMRConsistency.h:196

Arcane::mesh::FaceInfo
Infos sur une Face active.
Definition ParallelAMRConsistency.h:122

Arcane::mesh::FaceMapCoordToUid
Definition MapCoordToUid.h:175

Arcane::mesh::ItemInternalMap
Tableau associatif de ItemInternal.
Definition ItemInternalMap.h:56

Arcane::mesh::MapCoordToUid
structure de recherche d'un noeud à partir de ses coords La clef de hashage est la position geometriq...
Definition MapCoordToUid.h:47

Arcane::mesh::NodeInfo
Definition ParallelAMRConsistency.h:66

Arcane::mesh::NodeMapCoordToUid
Definition MapCoordToUid.h:142

Arcane::mesh::ParallelAMRConsistency::makeNewItemsConsistent2
void makeNewItemsConsistent2(MapCoordToUid &node_finder, MapCoordToUid &face_finder)
Détermine les faces à envoyer aux voisins.
Definition ParallelAMRConsistency.cc:577

Arcane::mesh::ParallelAMRConsistency::makeNewItemsConsistent
void makeNewItemsConsistent(NodeMapCoordToUid &node_finder, FaceMapCoordToUid &face_finder)
Détermine les faces à envoyer aux voisins.
Definition ParallelAMRConsistency.cc:168

Arcane::mesh::ParallelAMRConsistency::_gatherFaces
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)
Definition ParallelAMRConsistency.cc:362

Arcane::mesh::ParallelAMRConsistency::ParallelAMRConsistency
ParallelAMRConsistency(IMesh *mesh)
AMR.
Definition ParallelAMRConsistency.cc:69

Arccore::AbstractArray::size
Integer size() const
Nombre d'éléments du vecteur.
Definition arccore/src/collections/arccore/collections/Array.h:421

Arccore::Array::reserve
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
Definition arccore/src/collections/arccore/collections/Array.h:1220

Arccore::Array::add
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1151

Arccore::Array::clear
void clear()
Supprime les éléments du tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1349

Arccore::BasicSerializer::getArray
void getArray(Array< Real > &values) override
Redimensionne et remplit values.
Definition BasicSerializer.cc:1105

Arccore::BasicSerializer::getInteger
Integer getInteger() override
Récupère une taille.
Definition BasicSerializer.h:302

Arccore::BasicSerializer::setMode
void setMode(eMode new_mode) override
Positionne le fonctionnement actuel.
Definition BasicSerializer.cc:1204

Arccore::FatalErrorException
Exception lorsqu'une erreur fatale est survenue.
Definition arccore/src/base/arccore/base/FatalErrorException.h:32

Arccore::ISerializer::ModePut
@ ModePut
Le sérialiseur attend des reserve()
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:64

Arccore::ISerializer::ModeGet
@ ModeGet
Le sérialiseur attend des get()
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:65

Arccore::TraceAccessor
Classe d'accès aux traces.
Definition arccore/src/trace/arccore/trace/TraceAccessor.h:39

Arccore::TraceAccessor::error
TraceMessage error() const
Flot pour un message d'erreur.
Definition TraceAccessor.cc:201

Arccore::TraceAccessor::debug
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
Definition arccore/src/trace/arccore/trace/TraceAccessor.h:120

Arccore::TraceAccessor::info
TraceMessage info() const
Flot pour un message d'information.
Definition TraceAccessor.cc:101

Arccore::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1807

Arcane::math::cross
ARCCORE_HOST_DEVICE Real3 cross(Real3 v1, Real3 v2)
Produit vectoriel de deux vecteurs à 3 composantes.
Definition MathUtils.h:723

Arcane::math::isZero
bool isZero(const BuiltInProxy< _Type > &a)
Teste si une valeur est exactement égale à zéro.
Definition BuiltInProxy.h:164

Arcane::mesh
AMR.
Definition CartesianGridDimension.h:32

Arcane::arcaneCheckArraySize
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
Definition ArcaneGlobal.cc:152

Arcane::IK_Face
@ IK_Face
Entité de maillage de genre face.
Definition ArcaneTypes.h:156

Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240

Arcane::Real3POD::y
Real y
deuxième composante du triplet
Definition Real3.h:36

Arcane::Real3POD::z
Real z
troisième composante du triplet
Definition Real3.h:37

Arcane::Real3POD::x
Real x
première composante du triplet
Definition Real3.h:35