libMesh::Elem::PackedElem Class Reference

#include <elem.h>

List of all members.

Public Member Functions
	PackedElem (const std::vector< int >::const_iterator _buf_in)
Elem *	unpack (MeshBase &mesh, Elem *parent=NULL) const
unsigned int	level () const
unsigned int	p_level () const
Elem::RefinementState	refinement_flag () const
Elem::RefinementState	p_refinement_flag () const
ElemType	type () const
processor_id_type	processor_id () const
subdomain_id_type	subdomain_id () const
dof_id_type	id () const
int	parent_id () const
unsigned int	which_child_am_i () const
unsigned int	n_nodes () const
unsigned int	node (const unsigned int n) const
unsigned int	n_neighbors () const
unsigned int	neighbor (const unsigned int n) const
std::vector< int >::const_iterator	indices () const
unsigned int	packed_size () const
Static Public Member Functions
static void	pack (std::vector< int > &conn, const Elem *elem)
Static Public Attributes
static const unsigned int	header_size = 10
Private Attributes
const std::vector< int > ::const_iterator	_buf_begin

---

Detailed Description

Convenient way to communicate elements. This class packes up an element so that it can easily be communicated through an MPI array.

Author:

Benjamin S. Kirk

Date:

2008

Definition at line 2019 of file elem.h.

---

Constructor & Destructor Documentation

libMesh::Elem::PackedElem::PackedElem

(

const std::vector< int >::const_iterator

_buf_in

)

[inline]

Constructor. Takes an input iterator pointing to the beginning of the connectivity block for this element.

Definition at line 2034 of file elem.h.

                                                          :
    _buf_begin(_buf_in)
  {}

---

Member Function Documentation

dof_id_type libMesh::Elem::PackedElem::id

(

)

const [inline]

return the id of this packed element.

Definition at line 2131 of file elem.h.

References _buf_begin.

Referenced by unpack().

  {
    return static_cast<dof_id_type>(*(_buf_begin+7));
  }

std::vector<int>::const_iterator libMesh::Elem::PackedElem::indices

(

)

const [inline]

Definition at line 2186 of file elem.h.

References _buf_begin, header_size, n_neighbors(), and n_nodes().

Referenced by packed_size(), and unpack().

  {
    return _buf_begin + header_size + this->n_nodes() +
           this->n_neighbors();
  }

unsigned int libMesh::Elem::PackedElem::level

(

)

const [inline]

return the level of this packed element.

Definition at line 2063 of file elem.h.

Referenced by unpack().

  {
    return static_cast<unsigned int>(*_buf_begin);
  }

unsigned int libMesh::Elem::PackedElem::n_neighbors

(

)

const [inline]

return the number of neighbors of the packed element

Definition at line 2171 of file elem.h.

References type(), and libMesh::Elem::type_to_n_sides_map.

Referenced by indices(), packed_size(), and unpack().

  {
    return Elem::type_to_n_sides_map[this->type()];
  }

unsigned int libMesh::Elem::PackedElem::n_nodes

(

)

const [inline]

return the number of nodes in this packed element

Definition at line 2155 of file elem.h.

References type(), and libMesh::Elem::type_to_n_nodes_map.

Referenced by indices(), neighbor(), packed_size(), and unpack().

  {
    return Elem::type_to_n_nodes_map[this->type()];
  }

unsigned int libMesh::Elem::PackedElem::neighbor

(

const unsigned int

n

)

const [inline]

return the global index of the packed element's nth neighbor

Definition at line 2179 of file elem.h.

References _buf_begin, header_size, and n_nodes().

Referenced by unpack().

  {
    return static_cast<unsigned int>
      (*(_buf_begin + header_size + this->n_nodes() + n));
  }

unsigned int libMesh::Elem::PackedElem::node

(

const unsigned int

n

)

const [inline]

return the global index of the packed element's nth node.

Definition at line 2163 of file elem.h.

References _buf_begin, and header_size.

Referenced by unpack().

  {
    return static_cast<unsigned int>(*(_buf_begin+header_size+n));
  }

unsigned int libMesh::Elem::PackedElem::p_level

(

)

const [inline]

return the p-level of this packed element.

Definition at line 2071 of file elem.h.

References _buf_begin.

Referenced by unpack().

  {
    return static_cast<unsigned int>(*(_buf_begin+1));
  }

Elem::RefinementState libMesh::Elem::PackedElem::p_refinement_flag

(

)

const [inline]

return the p-refinement state of this packed element.

Definition at line 2090 of file elem.h.

References _buf_begin, and libMesh::Elem::INVALID_REFINEMENTSTATE.

Referenced by unpack().

  {
    libmesh_assert_greater_equal (*(_buf_begin+3), 0);
    libmesh_assert_less (*(_buf_begin+3), INVALID_REFINEMENTSTATE);
    return static_cast<Elem::RefinementState>(*(_buf_begin+3));
  }

void libMesh::Elem::PackedElem::pack	(	std::vector< int > &	conn,
		const Elem *	elem
	)			[static]

For each element the serialization is of the form [ level p_level r_flag p_r_flag etype processor_id subdomain_id self_ID parent_ID which_child node_0 node_1 ... node_n dof_object_buffer_1 ...] We cannot use unsigned int because parent_ID can be negative

Definition at line 2162 of file elem.C.

References libMesh::DofObject::id(), libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor(), libMesh::Elem::node(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::DofObject::pack_indexing(), libMesh::Elem::packed_size(), libMesh::Elem::parent(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::Elem::which_child_am_i().

{
  libmesh_assert(elem);

  // we can do at least this good. note that hopefully in general
  // the user will already have reserved the full space, which will render
  // this redundant
  conn.reserve (conn.size() + elem->packed_size());

#ifdef LIBMESH_ENABLE_AMR
  conn.push_back (static_cast<int>(elem->level()));
  conn.push_back (static_cast<int>(elem->p_level()));
  conn.push_back (static_cast<int>(elem->refinement_flag()));
  conn.push_back (static_cast<int>(elem->p_refinement_flag()));
#else
  conn.push_back (0);
  conn.push_back (0);
  conn.push_back (0);
  conn.push_back (0);
#endif
  conn.push_back (static_cast<int>(elem->type()));
  conn.push_back (elem->processor_id());
  conn.push_back (elem->subdomain_id());
  conn.push_back (elem->id());

#ifdef LIBMESH_ENABLE_AMR
  // use parent_ID of -1 to indicate a level 0 element
  if (elem->level() == 0)
    {
      conn.push_back(-1);
      conn.push_back(-1);
    }
  else
    {
      conn.push_back(elem->parent()->id());
      conn.push_back(elem->parent()->which_child_am_i(elem));
    }
#else
  conn.push_back (-1);
  conn.push_back (-1);
#endif

  for (unsigned int n=0; n<elem->n_nodes(); n++)
    conn.push_back (elem->node(n));

  for (unsigned int n=0; n<elem->n_neighbors(); n++)
    {
      Elem *neigh = elem->neighbor(n);
      if (neigh)
        conn.push_back (neigh->id());
      else
        conn.push_back (-1);
    }

  elem->pack_indexing(std::back_inserter(conn));
}

unsigned int libMesh::Elem::PackedElem::packed_size

(

)

const [inline]

Definition at line 2192 of file elem.h.

References header_size, indices(), n_neighbors(), n_nodes(), and libMesh::DofObject::unpackable_indexing_size().

  {
    return this->header_size + this->n_nodes() +
           this->n_neighbors() +
           DofObject::unpackable_indexing_size(this->indices());
  }

int libMesh::Elem::PackedElem::parent_id

(

)

const [inline]

return the parent id of this packed element.

Definition at line 2139 of file elem.h.

References _buf_begin.

  {
    return *(_buf_begin+8);
  }

processor_id_type libMesh::Elem::PackedElem::processor_id

(

)

const [inline]

return the processor id of this packed element.

Definition at line 2111 of file elem.h.

References _buf_begin, libMesh::DofObject::invalid_processor_id, and libMesh::n_processors().

Referenced by unpack().

  {
    libmesh_assert_greater_equal (*(_buf_begin+5), 0);
    libmesh_assert_less (static_cast<unsigned int>(*(_buf_begin+5)),
                   libMesh::n_processors() ||
                   static_cast<processor_id_type>(*(_buf_begin+5)) == DofObject::invalid_processor_id);
    return static_cast<processor_id_type>(*(_buf_begin+5));
  }

Elem::RefinementState libMesh::Elem::PackedElem::refinement_flag

(

)

const [inline]

return the refinement state of this packed element.

Definition at line 2080 of file elem.h.

References _buf_begin, and libMesh::Elem::INVALID_REFINEMENTSTATE.

Referenced by unpack().

  {
    libmesh_assert_greater_equal (*(_buf_begin+2), 0);
    libmesh_assert_less (*(_buf_begin+2), INVALID_REFINEMENTSTATE);
    return static_cast<Elem::RefinementState>(*(_buf_begin+2));
  }

subdomain_id_type libMesh::Elem::PackedElem::subdomain_id

(

)

const [inline]

return the subdomain id of this packed element.

Definition at line 2123 of file elem.h.

References _buf_begin.

Referenced by unpack().

  {
    return static_cast<subdomain_id_type>(*(_buf_begin+6));
  }

ElemType libMesh::Elem::PackedElem::type

(

)

const [inline]

return the element type of this packed element.

Definition at line 2101 of file elem.h.

References _buf_begin, and libMeshEnums::INVALID_ELEM.

Referenced by n_neighbors(), n_nodes(), and unpack().

  {
    libmesh_assert_greater_equal (*(_buf_begin+4), 0);
    libmesh_assert_less (*(_buf_begin+4), INVALID_ELEM);
    return static_cast<ElemType>(*(_buf_begin+4));
  }

Elem * libMesh::Elem::PackedElem::unpack	(	MeshBase &	mesh,
		Elem *	parent = NULL
	)			const

Unpacks this packed element. Returns a pointer to the new element. Takes a pointer to the parent, which is required unless this packed element is at level 0.

Definition at line 2221 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::add_child(), libMesh::Elem::build(), libMesh::Elem::child(), libMesh::Elem::family_tree_by_side(), libMesh::DofObject::id(), id(), indices(), libMesh::DofObject::invalid_id, libMesh::Elem::level(), level(), libMesh::Elem::n_children(), n_neighbors(), libMesh::Elem::n_neighbors(), n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), neighbor(), node(), libMesh::MeshBase::node_ptr(), p_level(), p_refinement_flag(), processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem(), refinement_flag(), libMesh::AutoPtr< Tp >::release(), libMesh::remote_elem, libMesh::DofObject::set_id(), 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::Elem::side(), libMesh::Elem::subactive(), subdomain_id(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), type(), libMesh::DofObject::unpack_indexing(), and which_child_am_i().

{

  Elem *elem = Elem::build(this->type(),parent).release();
  libmesh_assert (elem);

#ifdef LIBMESH_ENABLE_AMR
  if (this->level() != 0)
    {
      libmesh_assert(parent);
      parent->add_child(elem, this->which_child_am_i());
      libmesh_assert_equal_to (parent->type(), elem->type());
      libmesh_assert_equal_to (parent->child(this->which_child_am_i()), elem);
    }
#endif

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

  // If this element definitely should have children, assign
  // remote_elem for now; later unpacked elements may overwrite that.
  if (!elem->active())
    for (unsigned int c=0; c != elem->n_children(); ++c)
      elem->add_child(const_cast<RemoteElem*>(remote_elem), c);
#endif

  // Assign the IDs
  elem->subdomain_id() = this->subdomain_id();
  elem->processor_id() = this->processor_id();
  elem->set_id()       = this->id();

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

  for (unsigned int n=0; n<elem->n_nodes(); n++)
    elem->set_node(n) = mesh.node_ptr (this->node(n));

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

  for (unsigned int n=0; n<elem->n_neighbors(); n++)
    {
      dof_id_type neighbor_id = this->neighbor(n);

      // We should only be unpacking elements sent by their owners,
      // and their owners should know all their neighbors
      libmesh_assert_not_equal_to (neighbor_id, remote_elem->id());

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

      Elem *neigh = mesh.query_elem(neighbor_id);
      if (!neigh)
        {
          elem->set_neighbor(n, const_cast<RemoteElem*>(remote_elem));
          continue;
        }

      // We never have neighbors more refined than us
      libmesh_assert_less_equal (neigh->level(), elem->level());

      // We never have subactive neighbors of non subactive elements
      libmesh_assert(!neigh->subactive() || elem->subactive());

      // If we have a neighbor less refined than us then it must not
      // have any more refined active descendants we could have
      // pointed to instead.
      libmesh_assert(neigh->level() == elem->level() ||
                     neigh->active());
     
      elem->set_neighbor(n, neigh);

      // If neigh is at elem's level, then its family might have
      // remote_elem neighbor links which need to point to elem
      // instead, but if not, then we're done.
      if (neigh->level() != elem->level())
        continue;
      
      // What side of neigh is elem on?  We can't use the usual Elem
      // method because we haven't finished restoring topology
      const AutoPtr<Elem> my_side = elem->side(n);
      unsigned int nn = 0;
      for (; nn != neigh->n_sides(); ++nn)
        {
          const AutoPtr<Elem> neigh_side = neigh->side(nn);
          if (*my_side == *neigh_side)
            break;
        }

      // elem had better be on *some* side of neigh
      libmesh_assert_less (nn, neigh->n_sides());

      // Find any elements that ought to point to elem
      std::vector<const Elem*> neigh_family;
#ifdef LIBMESH_ENABLE_AMR
      if (!neigh->subactive())
        neigh->family_tree_by_side(neigh_family, nn);
#else
        neigh_family.push_back(neigh);
#endif

      // And point them to elem
      for (unsigned int i = 0; i != neigh_family.size(); ++i)
        {
          Elem* neigh_family_member = const_cast<Elem*>(neigh_family[i]);

          // The neighbor link ought to either be correct already or
          // ought to be to remote_elem
          libmesh_assert(neigh_family_member->neighbor(nn) == elem ||
                         neigh_family_member->neighbor(nn) == remote_elem);

          neigh_family_member->set_neighbor(nn, elem);
        }
    }

  elem->unpack_indexing(this->indices());

  return elem;
}

unsigned int libMesh::Elem::PackedElem::which_child_am_i

(

)

const [inline]

return which child this packed element is.

Definition at line 2147 of file elem.h.

References _buf_begin.

Referenced by unpack().

  {
    return static_cast<unsigned int>(*(_buf_begin+9));
  }

---

Member Data Documentation

const std::vector<int>::const_iterator libMesh::Elem::PackedElem::_buf_begin [private]

Iterator pointing to the beginning of this packed element's index buffer.

Definition at line 2026 of file elem.h.

Referenced by id(), indices(), neighbor(), node(), p_level(), p_refinement_flag(), parent_id(), processor_id(), refinement_flag(), subdomain_id(), type(), and which_child_am_i().

const unsigned int libMesh::Elem::PackedElem::header_size = 10 [static]

An Elem can be packed into an integer array which is header_size + elem->n_nodes() in length.

Definition at line 2042 of file elem.h.

Referenced by indices(), neighbor(), node(), libMesh::Elem::packed_size(), and packed_size().

---

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

• elem.h
• elem.C