libMesh::Parallel::Packing< Node * > Class Reference

#include <parallel_node.h>

Public Types
typedef largest_id_type	buffer_type

Public Member Functions
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)

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

Detailed Description

Definition at line 63 of file parallel_node.h.

Member Typedef Documentation

buffer_type

typedef largest_id_type libMesh::Parallel::Packing< Node * >::buffer_type

Definition at line 66 of file parallel_node.h.

Member Function Documentation

pack()

template<typename OutputIter , typename Context >

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

inlinestatic

Definition at line 69 of file parallel_node.h.

  { return Packing<const Node *>::pack(object, data_out, context); }

References libMesh::Parallel::Packing< typename T, typename Enable >::pack().

packable_size()

template<typename Context >

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

inlinestatic

Definition at line 75 of file parallel_node.h.

  { return Packing<const Node*>::packable_size(object, context); }

References libMesh::Parallel::Packing< typename T, typename Enable >::packable_size().

packed_size()

template<typename BufferIter >

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

inlinestatic

Definition at line 80 of file parallel_node.h.

  { return Packing<const Node *>::packed_size(iter); }

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

unpack() [1/4]

template<typename BufferIter , typename Context >

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

static

unpack() [2/4]

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.

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

References mesh.

unpack() [3/4]

template<>

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

Definition at line 182 of file parallel_node.C.

{
#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)
        {
          Real idtypes_as_Real;
          std::memcpy(&idtypes_as_Real, &(*in), sizeof(Real));
          in += idtypes_per_Real;
          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;
        }
 
      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.
      // There is no Node::build() API that lets you defer setting
      // the (x,y,z) values, so we just use the Node constructor.
      auto unode = std::make_unique<Node>();
 
      for (unsigned int i=0; i != LIBMESH_DIM; ++i)
        {
          Real idtypes_as_Real;
          std::memcpy(&idtypes_as_Real, &(*in), sizeof(Real));
          (*unode)(i) = idtypes_as_Real;
          in += idtypes_per_Real;
        }
 
      unode->set_id() = id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      unode->set_unique_id(unique_id);
#endif
      unode->processor_id() = processor_id;
 
      unode->unpack_indexing(in);
      libmesh_assert_equal_to (DofObject::unpackable_indexing_size(in),
                               unode->packed_indexing_size());
      in += unode->packed_indexing_size();
 
      node = mesh->add_node(std::move(unode));
    }
 
  // 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;
}

References libMesh::BoundaryInfo::add_node(), libMesh::MeshBase::add_node(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::has_dofs(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), mesh, libMesh::DofObject::packed_indexing_size(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::Real, libMesh::TOLERANCE, libMesh::DofObject::unpack_indexing(), and libMesh::DofObject::unpackable_indexing_size().

unpack() [4/4]

template<>

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

Definition at line 330 of file parallel_node.C.

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

References mesh.

---

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

• include/parallel/parallel_node.h
• src/parallel/parallel_node.C