libMesh::Parallel Namespace Reference

Namespaces
	Has_buffer_type
	PackingMixedType
	Utils

Classes
class	BinSorter
	Perform a parallel sort using a bin-sort method. More...
class	Communicator
struct	DefaultBufferType
struct	DefaultBufferType< T, typename std::enable_if< Has_buffer_type< Packing< T > >::value >::type >
struct	DefaultBufferType< T, typename std::enable_if<!Has_buffer_type< Packing< T > >::value >::type >
struct	DefaultValueType
struct	DefaultValueType< std::pair< const K, V > >
class	Has_buffer_type
class	Histogram
	Defines a histogram to be used in parallel in conjunction with a BinSorter. More...
class	Packing
class	Packing< const Elem * >
class	Packing< const Elem *const >
class	Packing< const Node * >
class	Packing< const Node *const >
class	Packing< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
class	Packing< Elem * >
class	Packing< Elem *const >
class	Packing< Node * >
class	Packing< Node *const >
class	Packing< std::array< T, N >, typename std::enable_if< Has_buffer_type< Packing< T > >::value >::type >
class	Packing< std::basic_string< T >, typename std::enable_if< TIMPI::StandardType< T >::is_fixed_type >::type >
class	Packing< std::pair< T1, T2 >, typename std::enable_if< PairHasPacking< T1, T2 >::value >::type >
class	Packing< std::tuple< T, Types... >, typename std::enable_if< TupleHasPacking< T, Types... >::value >::type >
class	Packing< std::tuple<>, Enable >
class	Packing< std::unique_ptr< int > >
struct	PackingMixedType
class	PackingRange
struct	PairBufferTypeHelper
struct	PairBufferTypeHelper< T1, false, T2, false >
struct	PairBufferTypeHelper< T1, false, T2, true >
struct	PairBufferTypeHelper< T1, true, T2, false >
struct	PairBufferTypeHelper< T1, true, T2, true >
struct	PairHasPacking
class	Sort
	The parallel sorting method is templated on the type of data which is to be sorted. More...
struct	SyncEverything
struct	TupleBufferType
struct	TupleBufferType< T1 >
struct	TupleBufferType< T1, MoreTypes... >
struct	TupleBufferTypeHelper
struct	TupleBufferTypeHelper< false, true, T1, MoreTypes... >
struct	TupleBufferTypeHelper< true, false, T1, MoreTypes... >
struct	TupleBufferTypeHelper< true, MoreTypes_have_buffer_Type, T1 >
struct	TupleBufferTypeHelper< true, true, T1, MoreTypes... >
struct	TupleHasPacking
struct	TupleHasPacking< T, Types... >
struct	TupleHasPacking<>

Typedefs
typedef std::pair< Hilbert::HilbertIndices, unique_id_type >	DofObjectKey

Functions
constexpr int	get_packed_len_entries ()
void	put_packed_len (unsigned int len, Iter data_out)
unsigned int	get_packed_len (typename std::vector< buffer_type >::const_iterator in)
	TIMPI_PACKING_RANGE_SUBCLASS (std::vector< T TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::list< T TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::vector< T TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::list< T TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
	TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
template<typename Iterator , typename DofObjType , typename SyncFunctor >
void	sync_dofobject_data_by_xyz (const Communicator &comm, const Iterator &range_begin, const Iterator &range_end, LocationMap< DofObjType > &location_map, SyncFunctor &sync)
	Request data about a range of ghost nodes uniquely identified by their xyz location or a range of active ghost elements uniquely identified by their vertex averages' xyz location. More...
template<typename Iterator , typename SyncFunctor >
void	sync_dofobject_data_by_id (const Communicator &comm, const Iterator &range_begin, const Iterator &range_end, SyncFunctor &sync)
	Request data about a range of ghost dofobjects uniquely identified by their id. More...
template<typename Iterator , typename DofObjectCheckFunctor , typename SyncFunctor >
void	sync_dofobject_data_by_id (const Communicator &comm, const Iterator &range_begin, const Iterator &range_end, const DofObjectCheckFunctor &dofobj_check, SyncFunctor &sync)
	Request data about a range of ghost dofobjects uniquely identified by their id. More...
template<typename Iterator , typename SyncFunctor >
void	sync_element_data_by_parent_id (MeshBase &mesh, const Iterator &range_begin, const Iterator &range_end, SyncFunctor &sync)
	Request data about a range of ghost elements uniquely identified by their parent id and which child they are. More...
template<typename ElemCheckFunctor , typename NodeCheckFunctor , typename SyncFunctor >
bool	sync_node_data_by_element_id_once (MeshBase &mesh, const MeshBase::const_element_iterator &range_begin, const MeshBase::const_element_iterator &range_end, const ElemCheckFunctor &elem_check, const NodeCheckFunctor &node_check, SyncFunctor &sync)
	Synchronize data about a range of ghost nodes uniquely identified by an element id and local node id, assuming a single synchronization pass is necessary. More...
template<typename ElemCheckFunctor , typename NodeCheckFunctor , typename SyncFunctor >
void	sync_node_data_by_element_id (MeshBase &mesh, const MeshBase::const_element_iterator &range_begin, const MeshBase::const_element_iterator &range_end, const ElemCheckFunctor &elem_check, const NodeCheckFunctor &node_check, SyncFunctor &sync)
	Synchronize data about a range of ghost nodes uniquely identified by an element id and local node id, iterating until data is completely in sync and further synchronization passes cause no changes. More...

Typedef Documentation

DofObjectKey

typedef Hilbert::HilbertIndices libMesh::Parallel::DofObjectKey

Definition at line 80 of file parallel_hilbert.h.

Function Documentation

sync_dofobject_data_by_id() [1/2]

template<typename Iterator , typename SyncFunctor >

void libMesh::Parallel::sync_dofobject_data_by_id	(	const Communicator &	comm,
		const Iterator &	range_begin,
		const Iterator &	range_end,
		SyncFunctor &	sync
	)

Request data about a range of ghost dofobjects uniquely identified by their id.

Fulfill requests with sync.gather_data(const std::vector<dof_id_type> & ids, std::vector<sync::datum> & data), by resizing and setting the values of the data vector. Respond to fulfillment with sync.act_on_data(const std::vector<dof_id_type> & ids, std::vector<sync::datum> & data) The user must define Parallel::StandardType<sync::datum> if sync::datum isn't a built-in type.

Definition at line 357 of file parallel_ghost_sync.h.

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::VariationalSmootherSystem::assembly(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::FEMSystem::mesh_position_set(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), and libMesh::MeshRefinement::uniformly_coarsen().

{
  sync_dofobject_data_by_id(comm, range_begin, range_end, SyncEverything(), sync);
}

sync_dofobject_data_by_id() [2/2]

template<typename Iterator , typename DofObjectCheckFunctor , typename SyncFunctor >

void libMesh::Parallel::sync_dofobject_data_by_id	(	const Communicator &	comm,
		const Iterator &	range_begin,
		const Iterator &	range_end,
		const DofObjectCheckFunctor &	dofobj_check,
		SyncFunctor &	sync
	)

Request data about a range of ghost dofobjects uniquely identified by their id.

Elements within the range can be excluded from the request by returning false from dofobj_check(dof_object)

Definition at line 368 of file parallel_ghost_sync.h.

References libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::DofObject::processor_id(), pull_parallel_vector_data(), and TIMPI::Communicator::rank().

{
  // This function must be run on all processors at once
  libmesh_parallel_only(comm);

  // Count the objects to ask each processor about
  std::map<processor_id_type, dof_id_type>
    ghost_objects_from_proc;

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      const DofObject * obj = *it;
      libmesh_assert (obj);

      // We may want to pass Elem* or Node* to the check function, not
      // just DofObject*
      if (!dofobj_check(*it))
        continue;

      processor_id_type obj_procid = obj->processor_id();
      if (obj_procid != DofObject::invalid_processor_id)
        ghost_objects_from_proc[obj_procid]++;
    }

  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_objs_id;

  // We know how many objects live on each processor, so reserve()
  // space for each.
  for (auto pair : ghost_objects_from_proc)
    {
      const processor_id_type p = pair.first;
      if (p != comm.rank())
        requested_objs_id[p].reserve(pair.second);
    }

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      const DofObject * obj = *it;

      if (!dofobj_check(*it))
        continue;

      processor_id_type obj_procid = obj->processor_id();
      if (obj_procid == comm.rank() ||
          obj_procid == DofObject::invalid_processor_id)
        continue;

      requested_objs_id[obj_procid].push_back(obj->id());
    }

  auto gather_functor =
    [&sync]
    (processor_id_type, const std::vector<dof_id_type> & ids,
     std::vector<typename SyncFunctor::datum> & data)
    {
      sync.gather_data(ids, data);
    };

  auto action_functor =
    [&sync]
    (processor_id_type, const std::vector<dof_id_type> & ids,
     const std::vector<typename SyncFunctor::datum> & data)
    {
      // Let the user process the results
      sync.act_on_data(ids, data);
    };

  // Trade requests with other processors
  typename SyncFunctor::datum * ex = nullptr;
  pull_parallel_vector_data
    (comm, requested_objs_id, gather_functor, action_functor, ex);
}

sync_dofobject_data_by_xyz()

template<typename Iterator , typename DofObjType , typename SyncFunctor >

void libMesh::Parallel::sync_dofobject_data_by_xyz	(	const Communicator &	comm,
		const Iterator &	range_begin,
		const Iterator &	range_end,
		LocationMap< DofObjType > &	location_map,
		SyncFunctor &	sync
	)

Request data about a range of ghost nodes uniquely identified by their xyz location or a range of active ghost elements uniquely identified by their vertex averages' xyz location.

Fulfill requests with sync.gather_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data), by resizing and setting the values of the data vector. Respond to fulfillment with sync.act_on_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data) The user must define Parallel::StandardType<sync::datum> if sync::datum isn't a built-in type. The user-provided location_map should be already filled.

This method may fail in cases of overlapping nodes or vertex averages, e.g. with slit meshes and/or overset meshes.

Definition at line 240 of file parallel_ghost_sync.h.

References libMesh::LocationMap< T >::empty(), libMesh::LocationMap< T >::find(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), TIMPI::Communicator::max(), libMesh::LocationMap< T >::point_of(), pull_parallel_vector_data(), and TIMPI::Communicator::rank().

Referenced by ParallelGhostSyncTest::testByXYZ().

{
  // This function must be run on all processors at once
  libmesh_parallel_only(comm);

  // We need a valid location_map
#ifdef DEBUG
  bool need_map_update = (range_begin != range_end && location_map.empty());
  comm.max(need_map_update);
  libmesh_assert(!need_map_update);
#endif

  // Count the objects to ask each processor about
  std::map<processor_id_type, dof_id_type>
    ghost_objects_from_proc;

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      DofObjType * obj = *it;
      libmesh_assert (obj);
      processor_id_type obj_procid = obj->processor_id();
      if (obj_procid != DofObject::invalid_processor_id)
        ghost_objects_from_proc[obj_procid]++;
    }

  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<Point>>
    requested_objs_pt;
  // Corresponding ids to keep track of
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_objs_id;

  // We know how many objects live on each processor, so reserve()
  // space for each.
  for (auto pair : ghost_objects_from_proc)
    {
      const processor_id_type p = pair.first;
      if (p != comm.rank())
        {
          requested_objs_pt[p].reserve(pair.second);
          requested_objs_id[p].reserve(pair.second);
        }
    }

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      DofObjType * obj = *it;
      processor_id_type obj_procid = obj->processor_id();
      if (obj_procid == comm.rank() ||
          obj_procid == DofObject::invalid_processor_id)
        continue;

      Point p = location_map.point_of(*obj);
      requested_objs_pt[obj_procid].push_back(p);
      requested_objs_id[obj_procid].push_back(obj->id());
    }

  std::map<const std::vector<Point> *, processor_id_type>
    requested_objs_pt_inv;
  for (auto & pair : requested_objs_pt)
    requested_objs_pt_inv[&pair.second] = pair.first;

  auto gather_functor =
    [&location_map, &sync]
    (processor_id_type /*pid*/, const std::vector<Point> & pts,
     std::vector<typename SyncFunctor::datum> & data)
    {
      // Find the local id of each requested object
      std::size_t query_size = pts.size();
      std::vector<dof_id_type> query_id(query_size);
      for (std::size_t i=0; i != query_size; ++i)
        {
          Point pt = pts[i];

          // Look for this object in the multimap
          DofObjType * obj = location_map.find(pt);

          // We'd better find every object we're asked for
          libmesh_assert (obj);

          // Return the object's correct processor id,
          // and our (correct if it's local) id for it.
          query_id[i] = obj->id();
        }

      // Gather whatever data the user wants
      sync.gather_data(query_id, data);
    };

  auto action_functor =
    [&sync, &requested_objs_id,
     &requested_objs_pt_inv]
    (processor_id_type /* pid */, const std::vector<Point> & point_request,
     const std::vector<typename SyncFunctor::datum> & data)
    {
      // With splits working on more pids than ranks, query_pid may not equal pid
      const processor_id_type query_pid =
        requested_objs_pt_inv[&point_request];

      // Let the user process the results
      sync.act_on_data(requested_objs_id[query_pid], data);
    };

  // Trade requests with other processors
  typename SyncFunctor::datum * ex = nullptr;
  pull_parallel_vector_data
    (comm, requested_objs_pt, gather_functor, action_functor, ex);
}

sync_element_data_by_parent_id()

template<typename Iterator , typename SyncFunctor >

void libMesh::Parallel::sync_element_data_by_parent_id	(	MeshBase &	mesh,
		const Iterator &	range_begin,
		const Iterator &	range_end,
		SyncFunctor &	sync
	)

Request data about a range of ghost elements uniquely identified by their parent id and which child they are.

Fulfill requests with sync.gather_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data), by resizing and setting the values of the data vector. Respond to fulfillment with sync.act_on_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data) The user must define Parallel::StandardType<sync::datum> if sync::datum isn't a built-in type.

Definition at line 453 of file parallel_ghost_sync.h.

References libMesh::Elem::active(), libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), mesh, libMesh::Elem::parent(), libMesh::DofObject::processor_id(), pull_parallel_vector_data(), and libMesh::Elem::which_child_am_i().

Referenced by libMesh::MeshCommunication::make_elems_parallel_consistent().

{
  const Communicator & comm (mesh.comm());

  // This function must be run on all processors at once
  libmesh_parallel_only(comm);

  // Count the objects to ask each processor about
  std::map<processor_id_type, dof_id_type>
    ghost_objects_from_proc;

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      Elem * elem = *it;
      processor_id_type obj_procid = elem->processor_id();
      if (obj_procid == comm.rank() ||
          obj_procid == DofObject::invalid_processor_id)
        continue;
      const Elem * parent = elem->parent();
      if (!parent || !elem->active())
        continue;

      ghost_objects_from_proc[obj_procid]++;
    }

  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_objs_id;
  std::map<processor_id_type, std::vector<std::pair<dof_id_type,unsigned char>>>
    requested_objs_parent_id_child_num;

  // We know how many objects live on each processor, so reserve()
  // space for each.
  for (auto pair : ghost_objects_from_proc)
    {
      const processor_id_type p = pair.first;
      if (p != comm.rank())
        {
          requested_objs_id[p].reserve(pair.second);
          requested_objs_parent_id_child_num[p].reserve(pair.second);
        }
    }

  for (Iterator it = range_begin; it != range_end; ++it)
    {
      Elem * elem = *it;
      processor_id_type obj_procid = elem->processor_id();
      if (obj_procid == comm.rank() ||
          obj_procid == DofObject::invalid_processor_id)
        continue;
      const Elem * parent = elem->parent();
      if (!parent || !elem->active())
        continue;

      requested_objs_id[obj_procid].push_back(elem->id());
      requested_objs_parent_id_child_num[obj_procid].emplace_back
        (parent->id(), cast_int<unsigned char>(parent->which_child_am_i(elem)));
    }

  std::map<const std::vector<std::pair<dof_id_type,unsigned char>> *, processor_id_type>
    requested_objs_parent_id_child_num_inv;
  for (auto & pair : requested_objs_parent_id_child_num)
    requested_objs_parent_id_child_num_inv[&pair.second] = pair.first;

  auto gather_functor =
    [&mesh, &sync]
    (processor_id_type,
     const std::vector<std::pair<dof_id_type, unsigned char>> & parent_id_child_num,
     std::vector<typename SyncFunctor::datum> & data)
    {
      // Find the id of each requested element
      std::size_t query_size = parent_id_child_num.size();
      std::vector<dof_id_type> query_id(query_size);
      for (std::size_t i=0; i != query_size; ++i)
        {
          Elem & parent = mesh.elem_ref(parent_id_child_num[i].first);
          libmesh_assert(parent.has_children());
          Elem * child = parent.child_ptr(parent_id_child_num[i].second);
          libmesh_assert(child);
          libmesh_assert(child->active());
          query_id[i] = child->id();
        }

      // Gather whatever data the user wants
      sync.gather_data(query_id, data);
    };

  auto action_functor =
    [&sync, &requested_objs_id,
     &requested_objs_parent_id_child_num_inv]
    (processor_id_type /* pid */,
     const std::vector<std::pair<dof_id_type, unsigned char>> & parent_id_child_num_request,
     const std::vector<typename SyncFunctor::datum> & data)
    {
      // With splits working on more pids than ranks, query_pid may not equal pid
      const processor_id_type query_pid =
        requested_objs_parent_id_child_num_inv[&parent_id_child_num_request];

      // Let the user process the results
      sync.act_on_data(requested_objs_id[query_pid], data);
    };

  // Trade requests with other processors
  typename SyncFunctor::datum * ex = nullptr;
  pull_parallel_vector_data
    (comm, requested_objs_parent_id_child_num, gather_functor,
     action_functor, ex);
}

sync_node_data_by_element_id()

template<typename ElemCheckFunctor , typename NodeCheckFunctor , typename SyncFunctor >

void libMesh::Parallel::sync_node_data_by_element_id	(	MeshBase &	mesh,
		const MeshBase::const_element_iterator &	range_begin,
		const MeshBase::const_element_iterator &	range_end,
		const ElemCheckFunctor &	elem_check,
		const NodeCheckFunctor &	node_check,
		SyncFunctor &	sync
	)

Synchronize data about a range of ghost nodes uniquely identified by an element id and local node id, iterating until data is completely in sync and further synchronization passes cause no changes.

Imagine a vertex surrounded by triangles, each on a different processor, with a ghosting policy that include only face neighbors and not point neighbors. Then the only way for authoritative information to trickle out from that vertex is by being passed along, one neighbor at a time, to processors who mostly don't even see the node's true owner!

Data for all nodes connected to elements in the given range of element iterators will be requested.

Elements can be further excluded from the request by returning false from element_check(elem)

Nodes can be further excluded from the request by returning false from node_check(elem, local_node_num)

Fulfill requests with sync.gather_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data), by resizing and setting the values of the data vector. Respond to fulfillment with bool sync.act_on_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data) and return true iff the response changed any data.

The user must define Parallel::StandardType<sync::datum> if sync::datum isn't a built-in type.

Definition at line 780 of file parallel_ghost_sync.h.

References mesh, and sync_node_data_by_element_id_once().

Referenced by libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), and libMesh::Partitioner::set_node_processor_ids().

{
  // This function must be run on all processors at once
  libmesh_parallel_only(mesh.comm());

  bool need_sync = false;

  do
    {
      need_sync =
        sync_node_data_by_element_id_once
          (mesh, range_begin, range_end, elem_check, node_check,
           sync);
    } while (need_sync);
}

sync_node_data_by_element_id_once()

template<typename ElemCheckFunctor , typename NodeCheckFunctor , typename SyncFunctor >

bool libMesh::Parallel::sync_node_data_by_element_id_once	(	MeshBase &	mesh,
		const MeshBase::const_element_iterator &	range_begin,
		const MeshBase::const_element_iterator &	range_end,
		const ElemCheckFunctor &	elem_check,
		const NodeCheckFunctor &	node_check,
		SyncFunctor &	sync
	)

Synchronize data about a range of ghost nodes uniquely identified by an element id and local node id, assuming a single synchronization pass is necessary.

Data for all nodes connected to elements in the given range of element iterators will be requested.

Elements can be further excluded from the request by returning false from element_check(elem)

Nodes can be further excluded from the request by returning false from node_check(elem, local_node_num)

Fulfill requests with sync.gather_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data), by resizing and setting the values of the data vector. Respond to fulfillment with bool sync.act_on_data(const std::vector<unsigned int> & ids, std::vector<sync::datum> & data) and return true iff the response changed any data.

The user must define Parallel::StandardType<sync::datum> if sync::datum isn't a built-in type.

This method returns true iff the sync pass changed any data on any processor.

Definition at line 580 of file parallel_ghost_sync.h.

References libMesh::as_range(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), mesh, libMesh::Elem::n_nodes(), libMesh::Elem::node_ref(), libMesh::DofObject::processor_id(), and pull_parallel_vector_data().

Referenced by libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), and sync_node_data_by_element_id().

{
  const Communicator & comm (mesh.comm());

  // Count the objects to ask each processor about
  std::map<processor_id_type, dof_id_type>
    ghost_objects_from_proc;

  for (const auto & elem : as_range(range_begin, range_end))
    {
      libmesh_assert (elem);

      if (!elem_check(elem))
        continue;

      const processor_id_type proc_id = elem->processor_id();

      bool i_have_elem =
        (proc_id == comm.rank() ||
         proc_id == DofObject::invalid_processor_id);

      if (elem->active() && i_have_elem)
        continue;

      for (auto n : elem->node_index_range())
        {
          if (!node_check(elem, n))
            continue;

          const processor_id_type node_pid =
            elem->node_ref(n).processor_id();

          if (i_have_elem && (node_pid == comm.rank()))
            continue;

          if (i_have_elem)
            {
              libmesh_assert_not_equal_to
                (node_pid, DofObject::invalid_processor_id);
              ghost_objects_from_proc[node_pid]++;
            }
          else
            {
              const processor_id_type request_pid =
                (node_pid == DofObject::invalid_processor_id) ?
                 proc_id : node_pid;
              ghost_objects_from_proc[request_pid]++;
            }
        }
    }

  // Now repeat that iteration, filling request sets this time.

  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, unsigned char>>>
    requested_objs_elem_id_node_num;

  // We know how many objects live on each processor, so reserve()
  // space for each.
  for (auto pair : ghost_objects_from_proc)
    {
      const processor_id_type p = pair.first;
      if (p != comm.rank())
        requested_objs_elem_id_node_num[p].reserve(ghost_objects_from_proc[p]);
    }

  for (const auto & elem : as_range(range_begin, range_end))
    {
      libmesh_assert (elem);

      if (!elem_check(elem))
        continue;

      const processor_id_type proc_id = elem->processor_id();

      bool i_have_elem =
        (proc_id == comm.rank() ||
         proc_id == DofObject::invalid_processor_id);

      if (elem->active() && i_have_elem)
        continue;

      const dof_id_type elem_id = elem->id();

      for (auto n : elem->node_index_range())
        {
          if (!node_check(elem, n))
            continue;

          const Node & node = elem->node_ref(n);
          const processor_id_type node_pid = node.processor_id();

          if (i_have_elem && (node_pid == comm.rank()))
            continue;

          if (i_have_elem)
            {
              libmesh_assert_not_equal_to
                (node_pid, DofObject::invalid_processor_id);
              requested_objs_elem_id_node_num[node_pid].emplace_back
                (elem_id, cast_int<unsigned char>(n));
            }
          else
            {
              const processor_id_type request_pid =
                (node_pid == DofObject::invalid_processor_id) ?
                 proc_id : node_pid;
              requested_objs_elem_id_node_num[request_pid].emplace_back
                (elem_id,cast_int<unsigned char>(n));
            }
        }
    }

  auto gather_functor =
    [&mesh, &sync]
    (processor_id_type,
     const std::vector<std::pair<dof_id_type, unsigned char>> & elem_id_node_num,
     std::vector<typename SyncFunctor::datum> & data)
    {
      // Find the id of each requested element
      std::size_t request_size = elem_id_node_num.size();
      std::vector<dof_id_type> query_id(request_size);
      for (std::size_t i=0; i != request_size; ++i)
        {
          // We might now get queries about remote elements, in which
          // case we'll have to ignore them and wait for the query
          // answer to filter to the querier via another source.
          const Elem * elem = mesh.query_elem_ptr(elem_id_node_num[i].first);

          if (elem)
            {
              const unsigned int n = elem_id_node_num[i].second;
              libmesh_assert_less (n, elem->n_nodes());

              const Node & node = elem->node_ref(n);

              // This isn't a safe assertion in the case where we're
              // syncing processor ids
              // libmesh_assert_equal_to (node->processor_id(), comm.rank());

              query_id[i] = node.id();
            }
          else
            query_id[i] = DofObject::invalid_id;
        }

      // Gather whatever data the user wants
      sync.gather_data(query_id, data);
    };

  bool data_changed = false;

  auto action_functor =
    [&sync, &mesh, &data_changed]
    (processor_id_type /* pid */,
     const std::vector<std::pair<dof_id_type, unsigned char>> & elem_id_node_num,
     const std::vector<typename SyncFunctor::datum> & data)
    {
      const std::size_t data_size = data.size();

      libmesh_assert_equal_to(elem_id_node_num.size(), data_size);

      std::vector<dof_id_type> requested_objs_id(data.size());

      for (auto i : IntRange<std::size_t>(0,data_size))
        {
          const Elem & elem = mesh.elem_ref(elem_id_node_num[i].first);
          const Node & node = elem.node_ref(elem_id_node_num[i].second);
          requested_objs_id[i] = node.id();
        }

      // Let the user process the results.  If any of the results
      // were different than what the user expected, then we may
      // need to sync again just in case this processor has to
      // pass on the changes to yet another processor.
      if (sync.act_on_data(requested_objs_id, data))
        data_changed = true;
    };

  // Trade requests with other processors
  typename SyncFunctor::datum * ex = nullptr;
  pull_parallel_vector_data
    (comm, requested_objs_elem_id_node_num, gather_functor,
     action_functor, ex);

  comm.max(data_changed);

  return data_changed;
}