libMesh::Parallel::Packing< T > Class Template Reference

#include <communicator.h>

Public Member Functions
template<>
unsigned int	packed_size (std::vector< largest_id_type >::const_iterator in)
template<>
unsigned int	packed_size (std::vector< largest_id_type >::iterator in)
template<>
unsigned int	packable_size (const Elem *const &elem, const MeshBase *mesh)
template<>
unsigned int	packable_size (const Elem *const &elem, const DistributedMesh *mesh)
template<>
unsigned int	packable_size (const Elem *const &elem, const ParallelMesh *mesh)
template<>
void	pack (const Elem *const &elem, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const MeshBase *mesh)
template<>
void	pack (const Elem *const &elem, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const DistributedMesh *mesh)
template<>
void	pack (const Elem *const &elem, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const ParallelMesh *mesh)
template<>
Elem *	unpack (std::vector< largest_id_type >::const_iterator in, MeshBase *mesh)
template<>
Elem *	unpack (std::vector< largest_id_type >::const_iterator in, DistributedMesh *mesh)
template<>
Elem *	unpack (std::vector< largest_id_type >::const_iterator in, ParallelMesh *mesh)
template<>
unsigned int	packable_size (const Node *const &node, const MeshBase *mesh)
template<>
unsigned int	packed_size (const std::vector< largest_id_type >::const_iterator in)
template<>
unsigned int	packed_size (const std::vector< largest_id_type >::iterator in)
template<>
unsigned int	packable_size (const Node *const &node, const DistributedMesh *mesh)
template<>
unsigned int	packable_size (const Node *const &node, const ParallelMesh *mesh)
template<>
void	pack (const Node *const &node, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const MeshBase *mesh)
template<>
void	pack (const Node *const &node, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const DistributedMesh *mesh)
template<>
void	pack (const Node *const &node, std::back_insert_iterator< std::vector< largest_id_type >> data_out, const ParallelMesh *mesh)
template<>
Node *	unpack (std::vector< largest_id_type >::const_iterator in, MeshBase *mesh)
template<>
Node *	unpack (std::vector< largest_id_type >::const_iterator in, DistributedMesh *mesh)
template<>
Node *	unpack (std::vector< largest_id_type >::const_iterator in, ParallelMesh *mesh)
template<typename BufferIter , typename Context >
const Elem *	unpack (BufferIter in, Context *ctx)
template<typename BufferIter , typename Context >
const Node *	unpack (BufferIter in, Context *ctx)

Static Public Member Functions
template<typename OutputIter , typename Context >
static void	pack (const T &object, OutputIter data_out, const Context *context)
template<typename Context >
static unsigned int	packable_size (const T &object, const Context *context)
template<typename BufferIter >
static unsigned int	packed_size (BufferIter iter)
template<typename BufferIter , typename Context >
static T	unpack (BufferIter in, Context *ctx)

Detailed Description

template<typename T>
class libMesh::Parallel::Packing< T >

Define data types and (un)serialization functions for use when encoding a potentially-variable-size object of type T.

Users will need to specialize this class for their particular data types.

Definition at line 57 of file communicator.h.

Member Function Documentation

pack() [1/7]

template<typename T>

template<typename OutputIter , typename Context >

static void libMesh::Parallel::Packing< T >::pack ( const T &  object, OutputIter  data_out, const Context *  context  )

static

Referenced by libMesh::Parallel::Packing< Elem * >::pack(), libMesh::Parallel::Packing< Node * >::pack(), libMesh::Parallel::Packing< T >::pack(), and libMesh::Parallel::pack_range().

pack() [2/7]

template<>

void libMesh::Parallel::Packing< const Node * >::pack	(	const Node *const &	node,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const MeshBase *	mesh
	)

Definition at line 134 of file parallel_node.C.

References libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::DofObject::invalid_unique_id, std::max(), mesh, libMesh::DofObject::pack_indexing(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

{
  libmesh_assert(node);

#ifndef NDEBUG
  *data_out++ = (node_magic_header);
#endif

  *data_out++ = (static_cast<largest_id_type>(node->processor_id()));
  *data_out++ = (static_cast<largest_id_type>(node->id()));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (node->valid_unique_id())
    *data_out++ = (static_cast<largest_id_type>(node->unique_id()));
  else
    // OK to send invalid unique id, we must not own this DOF
    *data_out++ = (static_cast<largest_id_type>(DofObject::invalid_unique_id));
#endif

  // use "(a+b-1)/b" trick to get a/b to round up
  static const unsigned int idtypes_per_Real =
    (sizeof(Real) + sizeof(largest_id_type) - 1) / sizeof(largest_id_type);

  for (unsigned int i=0; i != LIBMESH_DIM; ++i)
    {
      const largest_id_type * Real_as_idtypes =
        reinterpret_cast<const largest_id_type *>(&((*node)(i)));
      for (unsigned int j=0; j != idtypes_per_Real; ++j)
        {
          *data_out++ =(Real_as_idtypes[j]);
        }
    }

  // Add any DofObject indices
  node->pack_indexing(data_out);

  // Add any nodal boundary condition ids
  std::vector<boundary_id_type> bcs;
  mesh->get_boundary_info().boundary_ids(node, bcs);

  libmesh_assert(bcs.size() < std::numeric_limits<largest_id_type>::max());

  *data_out++ =(bcs.size());

  for (const auto & bid : bcs)
    *data_out++ = bid;
}

pack() [3/7]

template<>

void libMesh::Parallel::Packing< const Node * >::pack	(	const Node *const &	node,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const DistributedMesh *	mesh
	)

Definition at line 189 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::pack().

{
  pack(node, data_out, static_cast<const MeshBase*>(mesh));
}

pack() [4/7]

template<>

void libMesh::Parallel::Packing< const Node * >::pack	(	const Node *const &	node,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const ParallelMesh *	mesh
	)

Definition at line 201 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::pack().

{
  pack(node, data_out, static_cast<const MeshBase*>(mesh));
}

pack() [5/7]

template<>

void libMesh::Parallel::Packing< const Elem * >::pack	(	const Elem *const &	elem,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const MeshBase *	mesh
	)

Definition at line 205 of file parallel_elem.C.

References libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::dim(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::Elem::edge_index_range(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::DofObject::invalid_id, libMesh::Elem::INVALID_REFINEMENTSTATE, libMesh::DofObject::invalid_unique_id, libMesh::Elem::level(), mesh, libMesh::Elem::n_nodes(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::node_id(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::DofObject::pack_indexing(), libMesh::Elem::parent(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::BoundaryInfo::shellface_boundary_ids(), libMesh::Elem::side_index_range(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_unique_id(), and libMesh::Elem::which_child_am_i().

{
  libmesh_assert(elem);

#ifndef NDEBUG
  *data_out++ = elem_magic_header;
#endif

#ifdef LIBMESH_ENABLE_AMR
  *data_out++ = (static_cast<largest_id_type>(elem->level()));
  *data_out++ = (static_cast<largest_id_type>(elem->p_level()));

  // Encode both the refinement flag and whether the element has
  // children together.  This coding is unambiguous because our
  // refinement state encoding starts at 0 and ends at
  // INVALID_REFINEMENTSTATE
  largest_id_type refinement_info =
    static_cast<largest_id_type>(elem->refinement_flag());
  if (elem->has_children())
    refinement_info +=
      static_cast<largest_id_type>(Elem::INVALID_REFINEMENTSTATE) + 1;
  *data_out++ = (refinement_info);

  *data_out++ = (static_cast<largest_id_type>(elem->p_refinement_flag()));
#else
  *data_out++ = (0);
  *data_out++ = (0);
  *data_out++ = (0);
  *data_out++ = (0);
#endif
  *data_out++ = (static_cast<largest_id_type>(elem->type()));
  *data_out++ = (elem->processor_id());
  *data_out++ = (elem->subdomain_id());
  *data_out++ = (elem->id());

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (elem->valid_unique_id())
    *data_out++ = (static_cast<largest_id_type>(elem->unique_id()));
  else
    // OK to send invalid unique id, we must not own this DOF
    *data_out++ = (static_cast<largest_id_type>(DofObject::invalid_unique_id));
#endif

#ifdef LIBMESH_ENABLE_AMR
  // use parent_ID of invalid_id to indicate a level 0 element
  if (elem->level() == 0)
    {
      *data_out++ =(DofObject::invalid_id);
      *data_out++ =(DofObject::invalid_id);
    }
  else
    {
      *data_out++ =(elem->parent()->id());
      *data_out++ =(elem->parent()->which_child_am_i(elem));
    }
#else
  *data_out++ = (DofObject::invalid_id);
  *data_out++ = (DofObject::invalid_id);
#endif

  if ((elem->dim() < LIBMESH_DIM) &&
      elem->interior_parent())
    *data_out++ =(elem->interior_parent()->id());
  else
    *data_out++ =(DofObject::invalid_id);

  for (unsigned int n=0; n<elem->n_nodes(); n++)
    *data_out++ = (elem->node_id(n));

  for (auto neigh : elem->neighbor_ptr_range())
    {
      if (neigh)
        *data_out++ = (neigh->id());
      else
        *data_out++ = (DofObject::invalid_id);
    }

  // Add any DofObject indices
  elem->pack_indexing(data_out);

  // If this is a coarse element,
  // Add any element side boundary condition ids
  if (elem->level() == 0)
    {
      std::vector<boundary_id_type> bcs;
      for (auto s : elem->side_index_range())
        {
          mesh->get_boundary_info().boundary_ids(elem, s, bcs);

          *data_out++ =(bcs.size());

          for (const auto & bid : bcs)
            *data_out++ = bid;
        }

      for (auto e : elem->edge_index_range())
        {
          mesh->get_boundary_info().edge_boundary_ids(elem, e, bcs);

          *data_out++ =(bcs.size());

          for (const auto & bid : bcs)
            *data_out++ = bid;
        }

      for (unsigned short sf=0; sf != 2; ++sf)
        {
          mesh->get_boundary_info().shellface_boundary_ids(elem, sf, bcs);

          *data_out++ =(bcs.size());

          for (const auto & bid : bcs)
            *data_out++ = bid;
        }
    }
}

pack() [6/7]

template<>

void libMesh::Parallel::Packing< const Elem * >::pack	(	const Elem *const &	elem,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const DistributedMesh *	mesh
	)

Definition at line 329 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::pack().

{
  pack(elem, data_out, static_cast<const MeshBase*>(mesh));
}

pack() [7/7]

template<>

void libMesh::Parallel::Packing< const Elem * >::pack	(	const Elem *const &	elem,
		std::back_insert_iterator< std::vector< largest_id_type >>	data_out,
		const ParallelMesh *	mesh
	)

Definition at line 341 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::pack().

{
  pack(elem, data_out, static_cast<const MeshBase*>(mesh));
}

packable_size() [1/7]

template<typename T>

template<typename Context >

static unsigned int libMesh::Parallel::Packing< T >::packable_size ( const T &  object, const Context *  context  )

static

Referenced by libMesh::Parallel::pack_range(), libMesh::Parallel::Packing< Node * >::packable_size(), libMesh::Parallel::Packing< Elem * >::packable_size(), libMesh::Parallel::Packing< T >::packable_size(), and libMesh::Parallel::packed_range_size().

packable_size() [2/7]

template<>

unsigned int libMesh::Parallel::Packing< const Node * >::packable_size	(	const Node *const &	node,
		const MeshBase *	mesh
	)

Definition at line 62 of file parallel_node.C.

References libMesh::MeshBase::get_boundary_info(), mesh, libMesh::BoundaryInfo::n_boundary_ids(), and libMesh::DofObject::packed_indexing_size().

{
  return
#ifndef NDEBUG
    1 + // add an int for the magic header when testing
#endif
    header_size + LIBMESH_DIM*idtypes_per_Real +
    node->packed_indexing_size() +
    1 + mesh->get_boundary_info().n_boundary_ids(node);
}

packable_size() [3/7]

template<>

unsigned int libMesh::Parallel::Packing< const Node * >::packable_size	(	const Node *const &	node,
		const DistributedMesh *	mesh
	)

Definition at line 112 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::packable_size().

{
  return packable_size(node, static_cast<const MeshBase *>(mesh));
}

packable_size() [4/7]

template<>

unsigned int libMesh::Parallel::Packing< const Node * >::packable_size	(	const Node *const &	node,
		const ParallelMesh *	mesh
	)

Definition at line 123 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::packable_size().

{
  return packable_size(node, static_cast<const MeshBase *>(mesh));
}

packable_size() [5/7]

template<>

unsigned int libMesh::Parallel::Packing< const Elem * >::packable_size	(	const Elem *const &	elem,
		const MeshBase *	mesh
	)

Definition at line 145 of file parallel_elem.C.

References libMesh::MeshBase::get_boundary_info(), libMesh::Elem::level(), mesh, libMesh::BoundaryInfo::n_boundary_ids(), libMesh::BoundaryInfo::n_edge_boundary_ids(), libMesh::Elem::n_edges(), libMesh::Elem::n_nodes(), libMesh::BoundaryInfo::n_shellface_boundary_ids(), libMesh::Elem::n_sides(), and libMesh::DofObject::packed_indexing_size().

{
  unsigned int total_packed_bcs = 0;
  const unsigned short n_sides = elem->n_sides();

  if (elem->level() == 0)
    {
      total_packed_bcs += n_sides;
      for (unsigned short s = 0; s != n_sides; ++s)
        total_packed_bcs +=
          mesh->get_boundary_info().n_boundary_ids(elem,s);

      const unsigned short n_edges = elem->n_edges();
      total_packed_bcs += n_edges;
      for (unsigned short e = 0; e != n_edges; ++e)
        total_packed_bcs +=
          mesh->get_boundary_info().n_edge_boundary_ids(elem,e);

      total_packed_bcs += 2; // shellfaces
      for (unsigned short sf=0; sf != 2; ++sf)
        total_packed_bcs +=
          mesh->get_boundary_info().n_shellface_boundary_ids(elem,sf);
    }

  return
#ifndef NDEBUG
    1 + // add an int for the magic header when testing
#endif
    header_size + elem->n_nodes() + n_sides +
    elem->packed_indexing_size() + total_packed_bcs;
}

packable_size() [6/7]

template<>

unsigned int libMesh::Parallel::Packing< const Elem * >::packable_size	(	const Elem *const &	elem,
		const DistributedMesh *	mesh
	)

Definition at line 183 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::packable_size().

{
  return packable_size(elem, static_cast<const MeshBase *>(mesh));
}

packable_size() [7/7]

template<>

unsigned int libMesh::Parallel::Packing< const Elem * >::packable_size	(	const Elem *const &	elem,
		const ParallelMesh *	mesh
	)

Definition at line 194 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::packable_size().

{
  return packable_size(elem, static_cast<const MeshBase *>(mesh));
}

packed_size() [1/5]

template<>

unsigned int libMesh::Parallel::Packing< const Elem * >::packed_size

(

std::vector< largest_id_type >::const_iterator

in

)

Definition at line 59 of file parallel_elem.C.

References libMesh::INVALID_ELEM, n_nodes, libMesh::Elem::type_to_n_edges_map, libMesh::Elem::type_to_n_nodes_map, libMesh::Elem::type_to_n_sides_map, and libMesh::DofObject::unpackable_indexing_size().

{
#ifndef NDEBUG
  const largest_id_type packed_header = *in++;
  libmesh_assert_equal_to (packed_header, elem_magic_header);
#endif

  // int 0: level
  const unsigned int level =
    cast_int<unsigned int>(*in);

  // int 4: element type
  const int typeint = cast_int<int>(*(in+4));
  libmesh_assert_greater_equal (typeint, 0);
  libmesh_assert_less (typeint, INVALID_ELEM);
  const ElemType type =
    cast_int<ElemType>(typeint);

  const unsigned int n_nodes =
    Elem::type_to_n_nodes_map[type];

  const unsigned int n_sides =
    Elem::type_to_n_sides_map[type];

  const unsigned int n_edges =
    Elem::type_to_n_edges_map[type];

  const unsigned int pre_indexing_size =
    header_size + n_nodes + n_sides;

  const unsigned int indexing_size =
    DofObject::unpackable_indexing_size(in+pre_indexing_size);

  unsigned int total_packed_bc_data = 0;
  if (level == 0)
    {
      for (unsigned int s = 0; s != n_sides; ++s)
        {
          const int n_bcs = cast_int<int>
            (*(in + pre_indexing_size + indexing_size +
               total_packed_bc_data++));
          libmesh_assert_greater_equal (n_bcs, 0);
          total_packed_bc_data += n_bcs;
        }

      for (unsigned int e = 0; e != n_edges; ++e)
        {
          const int n_bcs = cast_int<int>
            (*(in + pre_indexing_size + indexing_size +
               total_packed_bc_data++));
          libmesh_assert_greater_equal (n_bcs, 0);
          total_packed_bc_data += n_bcs;
        }

      for (unsigned short sf=0; sf != 2; ++sf)
        {
          const int n_bcs = cast_int<int>
            (*(in + pre_indexing_size + indexing_size +
               total_packed_bc_data++));
          libmesh_assert_greater_equal (n_bcs, 0);
          total_packed_bc_data += n_bcs;
        }
    }

  return
#ifndef NDEBUG
    1 + // Account for magic header
#endif
    pre_indexing_size + indexing_size + total_packed_bc_data;
}

packed_size() [2/5]

template<typename T>

template<typename BufferIter >

static unsigned int libMesh::Parallel::Packing< T >::packed_size ( BufferIter  iter )

static

Referenced by libMesh::Parallel::pack_range(), libMesh::Parallel::Packing< Node * >::packed_size(), libMesh::Parallel::Packing< Elem * >::packed_size(), libMesh::Parallel::Packing< T >::packed_size(), and libMesh::Parallel::unpack_range().

packed_size() [3/5]

template<>

unsigned int libMesh::Parallel::Packing< const Node * >::packed_size

(

const std::vector< largest_id_type >::const_iterator

in

)

Definition at line 79 of file parallel_node.C.

References libMesh::DofObject::unpackable_indexing_size().

{
  const unsigned int pre_indexing_size =
#ifndef NDEBUG
    1 + // add an int for the magic header when testing
#endif
    header_size + LIBMESH_DIM*idtypes_per_Real;

  const unsigned int indexing_size =
    DofObject::unpackable_indexing_size(in+pre_indexing_size);

  const int n_bcs = cast_int<int>
    (*(in + pre_indexing_size + indexing_size));
  libmesh_assert_greater_equal (n_bcs, 0);

  return pre_indexing_size + indexing_size + 1 + n_bcs;
}

packed_size() [4/5]

template<>

unsigned int libMesh::Parallel::Packing< const Node * >::packed_size

(

const std::vector< largest_id_type >::iterator

in

)

Definition at line 102 of file parallel_node.C.

References libMesh::Parallel::Packing< T >::packed_size().

{
  return packed_size(std::vector<largest_id_type>::const_iterator(in));
}

packed_size() [5/5]

template<>

unsigned int libMesh::Parallel::Packing< const Elem * >::packed_size

(

std::vector< largest_id_type >::iterator

in

)

Definition at line 135 of file parallel_elem.C.

References libMesh::Parallel::Packing< T >::packed_size().

{
  return packed_size(std::vector<largest_id_type>::const_iterator(in));
}

unpack() [1/9]

template<typename T>

template<typename BufferIter , typename Context >

static T libMesh::Parallel::Packing< T >::unpack ( BufferIter  in, Context *  ctx  )

static

Referenced by libMesh::Parallel::Packing< T >::unpack(), and libMesh::Parallel::unpack_range().

unpack() [2/9]

template<typename T>

template<typename BufferIter , typename Context >

const Elem* libMesh::Parallel::Packing< T >::unpack ( BufferIter  in, Context *  ctx  )

inline

Definition at line 84 of file parallel_elem.h.

References libMesh::Parallel::Packing< T >::unpack().

{ return Packing<Elem*>::unpack(in, ctx); }

unpack() [3/9]

template<typename T>

template<typename BufferIter , typename Context >

const Node* libMesh::Parallel::Packing< T >::unpack ( BufferIter  in, Context *  ctx  )

inline

Definition at line 84 of file parallel_node.h.

References libMesh::Parallel::Packing< T >::unpack().

{ return Packing<Node *>::unpack(in, ctx); }

unpack() [4/9]

template<>

Node * libMesh::Parallel::Packing< Node * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		MeshBase *	mesh
	)

Definition at line 213 of file parallel_node.C.

References libMesh::BoundaryInfo::add_node(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::invalid_processor_id, std::max(), mesh, libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::Real, libMesh::TOLERANCE, and libMesh::DofObject::unpackable_indexing_size().

{
#ifndef NDEBUG
  const std::vector<largest_id_type>::const_iterator original_in = in;
  const largest_id_type incoming_header = *in++;
  libmesh_assert_equal_to (incoming_header, node_magic_header);
#endif

  const processor_id_type processor_id = cast_int<processor_id_type>(*in++);
  libmesh_assert(processor_id == DofObject::invalid_processor_id ||
                 processor_id < mesh->n_processors());

  const dof_id_type id = cast_int<dof_id_type>(*in++);

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  const unique_id_type unique_id = cast_int<unique_id_type>(*in++);
#endif

  Node * node = mesh->query_node_ptr(id);

  if (node)
    {
      libmesh_assert_equal_to (node->processor_id(), processor_id);

      // We currently don't communicate mesh motion via packed Nodes,
      // so it should usually be safe to assume (and assert) that Node
      // locations are consistent between processors.
      //
      // There may be exceptions due to rounding in file I/O, so we'll
      // only assert equality to within a tight tolerance, and we'll
      // believe the sender's node locations over our own if we don't
      // own the node.
      for (unsigned int i=0; i != LIBMESH_DIM; ++i)
        {
          const Real & idtypes_as_Real = *(reinterpret_cast<const Real *>(&(*in)));
          libmesh_assert_less_equal ((*node)(i), idtypes_as_Real + (std::max(Real(1),idtypes_as_Real)*TOLERANCE*TOLERANCE));
          libmesh_assert_greater_equal ((*node)(i), idtypes_as_Real - (std::max(Real(1),idtypes_as_Real)*TOLERANCE*TOLERANCE));

          if (processor_id != mesh->processor_id())
            (*node)(i) = idtypes_as_Real;
          in += idtypes_per_Real;
        }

      if (!node->has_dofs())
        {
          node->unpack_indexing(in);
          libmesh_assert_equal_to (DofObject::unpackable_indexing_size(in),
                                   node->packed_indexing_size());
          in += node->packed_indexing_size();
        }
      else
        {
          // FIXME: We should add some debug mode tests to ensure that
          // the encoded indexing is consistent
          in += DofObject::unpackable_indexing_size(in);
        }
    }
  else
    {
      // If we don't already have it, we need to allocate it
      node = new Node();

      for (unsigned int i=0; i != LIBMESH_DIM; ++i)
        {
          const Real * idtypes_as_Real = reinterpret_cast<const Real *>(&(*in));
          (*node)(i) = *idtypes_as_Real;
          in += idtypes_per_Real;
        }

      node->set_id() = id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      node->set_unique_id() = unique_id;
#endif
      node->processor_id() = processor_id;

      node->unpack_indexing(in);
      libmesh_assert_equal_to (DofObject::unpackable_indexing_size(in),
                               node->packed_indexing_size());
      in += node->packed_indexing_size();
    }

  // FIXME: We should add some debug mode tests to ensure that the
  // encoded boundary conditions are consistent

  // Add any nodal boundary condition ids
  const largest_id_type num_bcs = *in++;
  // libmesh_assert_greater_equal (num_bcs, 0);

  for (largest_id_type bc_it=0; bc_it < num_bcs; bc_it++)
    mesh->get_boundary_info().add_node
      (node, cast_int<boundary_id_type>(*in++));

#ifndef NDEBUG
  libmesh_assert (in - original_in ==
                  cast_int<int>
                  (Parallel::Packing<const Node*>::packed_size(original_in)));
#endif

  return node;
}

unpack() [5/9]

template<>

Node * libMesh::Parallel::Packing< Node * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		DistributedMesh *	mesh
	)

Definition at line 320 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::unpack().

{
  return unpack(in, static_cast<MeshBase*>(mesh));
}

unpack() [6/9]

template<>

Node * libMesh::Parallel::Packing< Node * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		ParallelMesh *	mesh
	)

Definition at line 331 of file parallel_node.C.

References mesh, and libMesh::Parallel::Packing< T >::unpack().

{
  return unpack(in, static_cast<MeshBase*>(mesh));
}

unpack() [7/9]

template<>

Elem * libMesh::Parallel::Packing< Elem * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		MeshBase *	mesh
	)

Definition at line 354 of file parallel_elem.C.

References libMesh::Elem::active(), libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::Elem::dim(), libMesh::Elem::edge_index_range(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::hack_p_level(), libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::INVALID_ELEM, libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::Elem::INVALID_REFINEMENTSTATE, libMesh::Elem::level(), libMesh::Elem::make_links_to_me_local(), mesh, libMesh::Elem::n_children(), n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::DofObject::packed_indexing_size(), libMesh::Elem::parent(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::DofObject::set_id(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_node(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_refinement_flag(), libMesh::DofObject::set_unique_id(), libMesh::Elem::side_index_range(), libMesh::Elem::subactive(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::Elem::type_to_n_nodes_map, and libMesh::DofObject::unpack_indexing().

{
#ifndef NDEBUG
  const std::vector<largest_id_type>::const_iterator original_in = in;

  const largest_id_type incoming_header = *in++;
  libmesh_assert_equal_to (incoming_header, elem_magic_header);
#endif

  // int 0: level
  const unsigned int level =
    cast_int<unsigned int>(*in++);

#ifdef LIBMESH_ENABLE_AMR
  // int 1: p level
  const unsigned int p_level =
    cast_int<unsigned int>(*in++);

  // int 2: refinement flag and encoded has_children
  const int rflag = cast_int<int>(*in++);
  const int invalid_rflag =
    cast_int<int>(Elem::INVALID_REFINEMENTSTATE);
  libmesh_assert_greater_equal (rflag, 0);

  libmesh_assert_less (rflag, invalid_rflag*2+1);

  const bool has_children = (rflag > invalid_rflag);

  const Elem::RefinementState refinement_flag = has_children ?
    cast_int<Elem::RefinementState>(rflag - invalid_rflag - 1) :
    cast_int<Elem::RefinementState>(rflag);

  // int 3: p refinement flag
  const int pflag = cast_int<int>(*in++);
  libmesh_assert_greater_equal (pflag, 0);
  libmesh_assert_less (pflag, Elem::INVALID_REFINEMENTSTATE);
  const Elem::RefinementState p_refinement_flag =
    cast_int<Elem::RefinementState>(pflag);
#else
  in += 3;
#endif // LIBMESH_ENABLE_AMR

  // int 4: element type
  const int typeint = cast_int<int>(*in++);
  libmesh_assert_greater_equal (typeint, 0);
  libmesh_assert_less (typeint, INVALID_ELEM);
  const ElemType type =
    cast_int<ElemType>(typeint);

  const unsigned int n_nodes =
    Elem::type_to_n_nodes_map[type];

  // int 5: processor id
  const processor_id_type processor_id =
    cast_int<processor_id_type>(*in++);
  libmesh_assert (processor_id < mesh->n_processors() ||
                  processor_id == DofObject::invalid_processor_id);

  // int 6: subdomain id
  const subdomain_id_type subdomain_id =
    cast_int<subdomain_id_type>(*in++);

  // int 7: dof object id
  const dof_id_type id =
    cast_int<dof_id_type>(*in++);
  libmesh_assert_not_equal_to (id, DofObject::invalid_id);

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // int 8: dof object unique id
  const unique_id_type unique_id =
    cast_int<unique_id_type>(*in++);
#endif

#ifdef LIBMESH_ENABLE_AMR
  // int 9: parent dof object id.
  // Note: If level==0, then (*in) == invalid_id.  In
  // this case, the equality check in cast_int<unsigned>(*in) will
  // never succeed.  Therefore, we should only attempt the more
  // rigorous cast verification in cases where level != 0.
  const dof_id_type parent_id =
    (level == 0)
    ? static_cast<dof_id_type>(*in++)
    : cast_int<dof_id_type>(*in++);
  libmesh_assert (level == 0 || parent_id != DofObject::invalid_id);
  libmesh_assert (level != 0 || parent_id == DofObject::invalid_id);

  // int 10: local child id
  // Note: If level==0, then which_child_am_i is not valid, so don't
  // do the more rigorous cast verification.
  const unsigned int which_child_am_i =
    (level == 0)
    ? static_cast<unsigned int>(*in++)
    : cast_int<unsigned int>(*in++);
#else
  in += 2;
#endif // LIBMESH_ENABLE_AMR

  const dof_id_type interior_parent_id =
    static_cast<dof_id_type>(*in++);

  // Make sure we don't miscount above when adding the "magic" header
  // plus the real data header
  libmesh_assert_equal_to (in - original_in, header_size + 1);

  Elem * elem = mesh->query_elem_ptr(id);

  // if we already have this element, make sure its
  // properties match, and update any missing neighbor
  // links, but then go on
  if (elem)
    {
      libmesh_assert_equal_to (elem->level(), level);
      libmesh_assert_equal_to (elem->id(), id);
      //#ifdef LIBMESH_ENABLE_UNIQUE_ID
      // No check for unique id sanity
      //#endif
      libmesh_assert_equal_to (elem->processor_id(), processor_id);
      libmesh_assert_equal_to (elem->subdomain_id(), subdomain_id);
      libmesh_assert_equal_to (elem->type(), type);
      libmesh_assert_equal_to (elem->n_nodes(), n_nodes);

#ifndef NDEBUG
      // All our nodes should be correct
      for (unsigned int i=0; i != n_nodes; ++i)
        libmesh_assert(elem->node_id(i) ==
                       cast_int<dof_id_type>(*in++));
#else
      in += n_nodes;
#endif

#ifdef LIBMESH_ENABLE_AMR
      libmesh_assert_equal_to (elem->refinement_flag(), refinement_flag);
      libmesh_assert_equal_to (elem->has_children(), has_children);

#ifdef DEBUG
      if (elem->active())
        {
          libmesh_assert_equal_to (elem->p_level(), p_level);
          libmesh_assert_equal_to (elem->p_refinement_flag(), p_refinement_flag);
        }
#endif

      libmesh_assert (!level || elem->parent() != nullptr);
      libmesh_assert (!level || elem->parent()->id() == parent_id);
      libmesh_assert (!level || elem->parent()->child_ptr(which_child_am_i) == elem);
#endif
      // Our interior_parent link should be "close to" correct - we
      // may have to update it, but we can check for some
      // inconsistencies.
      {
        // If the sending processor sees no interior_parent here, we'd
        // better agree.
        if (interior_parent_id == DofObject::invalid_id)
          {
            if (elem->dim() < LIBMESH_DIM)
              libmesh_assert (!(elem->interior_parent()));
          }

        // If the sending processor has a remote_elem interior_parent,
        // then all we know is that we'd better have *some*
        // interior_parent
        else if (interior_parent_id == remote_elem->id())
          {
            libmesh_assert(elem->interior_parent());
          }
        else
          {
            Elem * ip = mesh->query_elem_ptr(interior_parent_id);

            // The sending processor sees an interior parent here, so
            // if we don't have that interior element, then we'd
            // better have a remote_elem signifying that fact.
            if (!ip)
              libmesh_assert_equal_to (elem->interior_parent(), remote_elem);
            else
              {
                // The sending processor has an interior_parent here,
                // and we have that element, but that does *NOT* mean
                // we're already linking to it.  Perhaps we initially
                // received elem from a processor on which the
                // interior_parent link was remote?
                libmesh_assert(elem->interior_parent() == ip ||
                               elem->interior_parent() == remote_elem);

                // If the link was originally remote, update it
                if (elem->interior_parent() == remote_elem)
                  {
                    elem->set_interior_parent(ip);
                  }
              }
          }
      }

      // Our neighbor links should be "close to" correct - we may have
      // to update a remote_elem link, and we can check for possible
      // inconsistencies along the way.
      //
      // For subactive elements, we don't bother keeping neighbor
      // links in good shape, so there's nothing we need to set or can
      // safely assert here.
      if (!elem->subactive())
        for (auto n : elem->side_index_range())
          {
            const dof_id_type neighbor_id =
              cast_int<dof_id_type>(*in++);

            // If the sending processor sees a domain boundary here,
            // we'd better agree.
            if (neighbor_id == DofObject::invalid_id)
              {
                libmesh_assert (!(elem->neighbor_ptr(n)));
                continue;
              }

            // If the sending processor has a remote_elem neighbor here,
            // then all we know is that we'd better *not* have a domain
            // boundary.
            if (neighbor_id == remote_elem->id())
              {
                libmesh_assert(elem->neighbor_ptr(n));
                continue;
              }

            Elem * neigh = mesh->query_elem_ptr(neighbor_id);

            // The sending processor sees a neighbor here, so if we
            // don't have that neighboring element, then we'd better
            // have a remote_elem signifying that fact.
            if (!neigh)
              {
                libmesh_assert_equal_to (elem->neighbor_ptr(n), remote_elem);
                continue;
              }

            // The sending processor has a neighbor here, and we have
            // that element, but that does *NOT* mean we're already
            // linking to it.  Perhaps we initially received both elem
            // and neigh from processors on which their mutual link was
            // remote?
            libmesh_assert(elem->neighbor_ptr(n) == neigh ||
                           elem->neighbor_ptr(n) == remote_elem);

            // If the link was originally remote, we should update it,
            // and make sure the appropriate parts of its family link
            // back to us.
            if (elem->neighbor_ptr(n) == remote_elem)
              {
                elem->set_neighbor(n, neigh);

                elem->make_links_to_me_local(n);
              }
          }

      // Our p level and refinement flags should be "close to" correct
      // if we're not an active element - we might have a p level
      // increased or decreased by changes in remote_elem children.
      //
      // But if we have remote_elem children, then we shouldn't be
      // doing a projection on this inactive element on this
      // processor, so we won't need correct p settings.  Couldn't
      // hurt to update, though.
#ifdef LIBMESH_ENABLE_AMR
      if (elem->processor_id() != mesh->processor_id())
        {
          elem->hack_p_level(p_level);
          elem->set_p_refinement_flag(p_refinement_flag);
        }
#endif // LIBMESH_ENABLE_AMR

      // FIXME: We should add some debug mode tests to ensure that the
      // encoded indexing and boundary conditions are consistent.
    }
  else
    {
      // We don't already have the element, so we need to create it.

      // Find the parent if necessary
      Elem * parent = nullptr;
#ifdef LIBMESH_ENABLE_AMR
      // Find a child element's parent
      if (level > 0)
        {
          // Note that we must be very careful to construct the send
          // connectivity so that parents are encountered before
          // children.  If we get here and can't find the parent that
          // is a fatal error.
          parent = mesh->elem_ptr(parent_id);
        }
      // Or assert that the sending processor sees no parent
      else
        libmesh_assert_equal_to (parent_id, DofObject::invalid_id);
#else
      // No non-level-0 elements without AMR
      libmesh_assert_equal_to (level, 0);
#endif

      elem = Elem::build(type,parent).release();
      libmesh_assert (elem);

#ifdef LIBMESH_ENABLE_AMR
      if (level != 0)
        {
          // Since this is a newly created element, the parent must
          // have previously thought of this child as a remote element.
          libmesh_assert_equal_to (parent->child_ptr(which_child_am_i), remote_elem);

          parent->add_child(elem, which_child_am_i);
        }

      // Assign the refinement flags and levels
      elem->set_p_level(p_level);
      elem->set_refinement_flag(refinement_flag);
      elem->set_p_refinement_flag(p_refinement_flag);
      libmesh_assert_equal_to (elem->level(), level);

      // If this element should have children, assign remote_elem to
      // all of them for now, for consistency.  Later unpacked
      // elements may overwrite that.
      if (has_children)
        {
          const unsigned int nc = elem->n_children();
          for (unsigned int c=0; c != nc; ++c)
            elem->add_child(const_cast<RemoteElem *>(remote_elem), c);
        }

#endif // LIBMESH_ENABLE_AMR

      // Assign the IDs
      elem->subdomain_id()  = subdomain_id;
      elem->processor_id()  = processor_id;
      elem->set_id()        = id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      elem->set_unique_id() = unique_id;
#endif

      // Assign the connectivity
      libmesh_assert_equal_to (elem->n_nodes(), n_nodes);

      for (unsigned int n=0; n != n_nodes; n++)
        elem->set_node(n) =
          mesh->node_ptr
          (cast_int<dof_id_type>(*in++));

      // Set interior_parent if found
      {
        // We may be unpacking an element that was a ghost element on the
        // sender, in which case the element's interior_parent may not be
        // known by the packed element.  We'll have to set such
        // interior_parents to remote_elem ourselves and wait for a
        // later packed element to give us better information.
        if (interior_parent_id == remote_elem->id())
          {
            elem->set_interior_parent
              (const_cast<RemoteElem *>(remote_elem));
          }
        else if (interior_parent_id != DofObject::invalid_id)
          {
            // If we don't have the interior parent element, then it's
            // a remote_elem until we get it.
            Elem * ip = mesh->query_elem_ptr(interior_parent_id);
            if (!ip )
              elem->set_interior_parent
                (const_cast<RemoteElem *>(remote_elem));
            else
              elem->set_interior_parent(ip);
          }
      }

      for (auto n : elem->side_index_range())
        {
          const dof_id_type neighbor_id =
            cast_int<dof_id_type>(*in++);

          if (neighbor_id == DofObject::invalid_id)
            continue;

          // We may be unpacking an element that was a ghost element on the
          // sender, in which case the element's neighbors may not all be
          // known by the packed element.  We'll have to set such
          // neighbors to remote_elem ourselves and wait for a later
          // packed element to give us better information.
          if (neighbor_id == remote_elem->id())
            {
              elem->set_neighbor(n, const_cast<RemoteElem *>(remote_elem));
              continue;
            }

          // If we don't have the neighbor element, then it's a
          // remote_elem until we get it.
          Elem * neigh = mesh->query_elem_ptr(neighbor_id);
          if (!neigh)
            {
              elem->set_neighbor(n, const_cast<RemoteElem *>(remote_elem));
              continue;
            }

          // If we have the neighbor element, then link to it, and
          // make sure the appropriate parts of its family link back
          // to us.
          elem->set_neighbor(n, neigh);

          elem->make_links_to_me_local(n);
        }

      elem->unpack_indexing(in);
    }

  in += elem->packed_indexing_size();

  // If this is a coarse element,
  // add any element side or edge boundary condition ids
  if (level == 0)
    {
      for (auto s : elem->side_index_range())
        {
          const boundary_id_type num_bcs =
            cast_int<boundary_id_type>(*in++);

          for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
            mesh->get_boundary_info().add_side
              (elem, s, cast_int<boundary_id_type>(*in++));
        }

      for (auto e : elem->edge_index_range())
        {
          const boundary_id_type num_bcs =
            cast_int<boundary_id_type>(*in++);

          for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
            mesh->get_boundary_info().add_edge
              (elem, e, cast_int<boundary_id_type>(*in++));
        }

      for (unsigned short sf=0; sf != 2; ++sf)
        {
          const boundary_id_type num_bcs =
            cast_int<boundary_id_type>(*in++);

          for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
            mesh->get_boundary_info().add_shellface
              (elem, sf, cast_int<boundary_id_type>(*in++));
        }
    }

  // Return the new element
  return elem;
}

unpack() [8/9]

template<>

Elem * libMesh::Parallel::Packing< Elem * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		DistributedMesh *	mesh
	)

Definition at line 808 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::unpack().

{
  return unpack(in, static_cast<MeshBase*>(mesh));
}

unpack() [9/9]

template<>

Elem * libMesh::Parallel::Packing< Elem * >::unpack	(	std::vector< largest_id_type >::const_iterator	in,
		ParallelMesh *	mesh
	)

Definition at line 819 of file parallel_elem.C.

References mesh, and libMesh::Parallel::Packing< T >::unpack().

{
  return unpack(in, static_cast<MeshBase*>(mesh));
}

---

The documentation for this class was generated from the following files:

• communicator.h
• packing.h
• parallel_elem.h
• parallel_node.h