#include <cell_pyramid5.h>

Inheritance diagram for libMesh::Pyramid5:

Public Types
enum	RefinementState { COARSEN = 0, DO_NOTHING, REFINE, JUST_REFINED, JUST_COARSENED, INACTIVE, COARSEN_INACTIVE, INVALID_REFINEMENTSTATE }
typedef Predicates::multi_predicate	Predicate
Public Member Functions
	Pyramid5 (Elem *p=NULL)
ElemType	type () const
unsigned int	n_sub_elem () const
virtual bool	is_vertex (const unsigned int i) const
virtual bool	is_edge (const unsigned int i) const
virtual bool	is_face (const unsigned int i) const
virtual bool	is_node_on_side (const unsigned int n, const unsigned int s) const
virtual bool	is_node_on_edge (const unsigned int n, const unsigned int e) const
virtual bool	has_affine_map () const
Order	default_order () const
UniquePtr< Elem >	build_side (const unsigned int i, bool proxy) const
UniquePtr< Elem >	build_edge (const unsigned int i) const
virtual void	connectivity (const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const
virtual Real	volume () const
unsigned int	n_nodes () const
unsigned int	n_sides () const
unsigned int	n_vertices () const
unsigned int	n_edges () const
unsigned int	n_faces () const
unsigned int	n_children () const
virtual bool	is_child_on_side (const unsigned int c, const unsigned int s) const
virtual bool	is_edge_on_side (const unsigned int e, const unsigned int s) const
dof_id_type	key (const unsigned int s) const
UniquePtr< Elem >	side (const unsigned int i) const
unsigned int	dim () const
bool	infinite () const
const Point &	point (const unsigned int i) const
Point &	point (const unsigned int i)
dof_id_type	node (const unsigned int i) const
unsigned int	local_node (const dof_id_type i) const
unsigned int	get_node_index (const Node *node_ptr) const
const Node const	get_nodes () const
Node *	get_node (const unsigned int i) const
virtual Node *&	set_node (const unsigned int i)
subdomain_id_type	subdomain_id () const
subdomain_id_type &	subdomain_id ()
const Elem *	reference_elem () const
bool	operator== (const Elem &rhs) const
Elem *	neighbor (const unsigned int i) const
const Elem *	topological_neighbor (const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
Elem *	topological_neighbor (const unsigned int i, MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb)
bool	has_topological_neighbor (const Elem elem, const MeshBase &mesh, const PointLocatorBase &point_locator, PeriodicBoundaries pb) const
void	set_neighbor (const unsigned int i, Elem *n)
bool	has_neighbor (const Elem *elem) const
Elem *	child_neighbor (Elem *elem) const
const Elem *	child_neighbor (const Elem *elem) const
bool	on_boundary () const
bool	is_semilocal (const processor_id_type my_pid) const
unsigned int	which_neighbor_am_i (const Elem *e) const
unsigned int	which_side_am_i (const Elem *e) const
bool	contains_vertex_of (const Elem *e) const
bool	contains_edge_of (const Elem *e) const
void	find_point_neighbors (const Point &p, std::set< const Elem * > &neighbor_set) const
void	find_point_neighbors (std::set< const Elem * > &neighbor_set) const
void	find_edge_neighbors (const Point &p1, const Point &p2, std::set< const Elem * > &neighbor_set) const
void	find_edge_neighbors (std::set< const Elem * > &neighbor_set) const
void	make_links_to_me_remote ()
void	make_links_to_me_local (unsigned int n)
virtual bool	is_remote () const
void	write_connectivity (std::ostream &out, const IOPackage iop) const
virtual unsigned int	n_neighbors () const
virtual unsigned int	opposite_side (const unsigned int s) const
virtual unsigned int	opposite_node (const unsigned int n, const unsigned int s) const
virtual Point	centroid () const
virtual Real	hmin () const
virtual Real	hmax () const
virtual Real	quality (const ElemQuality q) const
virtual std::pair< Real, Real >	qual_bounds (const ElemQuality) const
virtual bool	contains_point (const Point &p, Real tol=TOLERANCE) const
virtual bool	close_to_point (const Point &p, Real tol) const
virtual bool	is_linear () const
void	print_info (std::ostream &os=libMesh::out) const
std::string	get_info () const
bool	active () const
bool	ancestor () const
bool	subactive () const
bool	has_children () const
bool	has_ancestor_children () const
bool	is_ancestor_of (const Elem *descendant) const
const Elem *	parent () const
Elem *	parent ()
void	set_parent (Elem *p)
const Elem *	top_parent () const
const Elem *	interior_parent () const
void	set_interior_parent (Elem *p)
Real	length (const unsigned int n1, const unsigned int n2) const
virtual unsigned int	n_second_order_adjacent_vertices (const unsigned int n) const
virtual unsigned short int	second_order_adjacent_vertex (const unsigned int n, const unsigned int v) const
virtual std::pair< unsigned short int, unsigned short int >	second_order_child_vertex (const unsigned int n) const
unsigned int	level () const
unsigned int	p_level () const
Elem *	child (const unsigned int i) const
unsigned int	which_child_am_i (const Elem *e) const
virtual bool	is_child_on_edge (const unsigned int c, const unsigned int e) const
void	add_child (Elem *elem)
void	add_child (Elem *elem, unsigned int c)
void	replace_child (Elem *elem, unsigned int c)
void	family_tree (std::vector< const Elem * > &family, const bool reset=true) const
void	total_family_tree (std::vector< const Elem * > &active_family, const bool reset=true) const
void	active_family_tree (std::vector< const Elem * > &active_family, const bool reset=true) const
void	family_tree_by_side (std::vector< const Elem * > &family, const unsigned int side, const bool reset=true) const
void	active_family_tree_by_side (std::vector< const Elem * > &family, const unsigned int side, const bool reset=true) const
void	family_tree_by_neighbor (std::vector< const Elem * > &family, const Elem *neighbor, const bool reset=true) const
void	family_tree_by_subneighbor (std::vector< const Elem * > &family, const Elem neighbor, const Elem subneighbor, const bool reset=true) const
void	active_family_tree_by_neighbor (std::vector< const Elem * > &family, const Elem *neighbor, const bool reset=true) const
RefinementState	refinement_flag () const
void	set_refinement_flag (const RefinementState rflag)
RefinementState	p_refinement_flag () const
void	set_p_refinement_flag (const RefinementState pflag)
unsigned int	max_descendant_p_level () const
unsigned int	min_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const
unsigned int	min_new_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const
void	set_p_level (const unsigned int p)
void	hack_p_level (const unsigned int p)
virtual void	refine (MeshRefinement &mesh_refinement)
void	coarsen ()
void	contract ()
void	libmesh_assert_valid_neighbors () const
void	libmesh_assert_valid_node_pointers () const
side_iterator	boundary_sides_begin ()
side_iterator	boundary_sides_end ()
virtual Point	origin () const
void	nullify_neighbors ()
void	clear_old_dof_object ()
void	set_old_dof_object ()
void	clear_dofs ()
void	invalidate_dofs (const unsigned int sys_num=libMesh::invalid_uint)
void	invalidate_id ()
void	invalidate_processor_id ()
void	invalidate ()
unsigned int	n_dofs (const unsigned int s, const unsigned int var=libMesh::invalid_uint) const
dof_id_type	id () const
dof_id_type &	set_id ()
void	set_id (const dof_id_type dofid)
unique_id_type	unique_id () const
unique_id_type &	set_unique_id ()
bool	valid_id () const
bool	valid_unique_id () const
processor_id_type	processor_id () const
processor_id_type &	processor_id ()
void	processor_id (const processor_id_type pid)
bool	valid_processor_id () const
unsigned int	n_systems () const
void	set_n_systems (const unsigned int s)
void	add_system ()
unsigned int	n_var_groups (const unsigned int s) const
unsigned int	n_vars (const unsigned int s, const unsigned int vg) const
unsigned int	n_vars (const unsigned int s) const
void	set_n_vars_per_group (const unsigned int s, const std::vector< unsigned int > &nvpg)
unsigned int	n_comp (const unsigned int s, const unsigned int var) const
unsigned int	n_comp_group (const unsigned int s, const unsigned int vg) const
void	set_n_comp (const unsigned int s, const unsigned int var, const unsigned int ncomp)
void	set_n_comp_group (const unsigned int s, const unsigned int vg, const unsigned int ncomp)
dof_id_type	dof_number (const unsigned int s, const unsigned int var, const unsigned int comp) const
void	set_dof_number (const unsigned int s, const unsigned int var, const unsigned int comp, const dof_id_type dn)
bool	has_dofs (const unsigned int s=libMesh::invalid_uint) const
void	set_vg_dof_base (const unsigned int s, const unsigned int vg, const dof_id_type db)
dof_id_type	vg_dof_base (const unsigned int s, const unsigned int vg) const
unsigned int	packed_indexing_size () const
void	unpack_indexing (std::vector< largest_id_type >::const_iterator begin)
void	pack_indexing (std::back_insert_iterator< std::vector< largest_id_type > > target) const
void	debug_buffer () const
void	set_buffer (const std::vector< dof_id_type > &buf)
Static Public Member Functions
static void	print_info (std::ostream &out=libMesh::out)
static void	print_info (std::ostream &out=libMesh::out)
static std::string	get_info ()
static std::string	get_info ()
static ElemType	second_order_equivalent_type (const ElemType et, const bool full_ordered=true)
static ElemType	first_order_equivalent_type (const ElemType et)
static UniquePtr< Elem >	build (const ElemType type, Elem *p=NULL)
static unsigned int	n_objects ()
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
static void	disable_print_counter_info ()
static unsigned int	unpackable_indexing_size (std::vector< largest_id_type >::const_iterator begin)
Public Attributes
DofObject *	old_dof_object
Static Public Attributes
static const unsigned int	side_nodes_map [5][4]
static const unsigned int	edge_nodes_map [8][2]
static const subdomain_id_type	invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
static const unsigned int	type_to_n_nodes_map [INVALID_ELEM]
static const unsigned int	type_to_n_sides_map [INVALID_ELEM]
static const unsigned int	type_to_n_edges_map [INVALID_ELEM]
static const dof_id_type	invalid_id = static_cast<dof_id_type>(-1)
static const unique_id_type	invalid_unique_id = static_cast<unique_id_type>(-1)
static const processor_id_type	invalid_processor_id = static_cast<processor_id_type>(-1)
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
float	embedding_matrix (const unsigned int, const unsigned int, const unsigned int) const
unsigned int	side_children_matrix (const unsigned int, const unsigned int) const
void	increment_constructor_count (const std::string &name)
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Static Protected Member Functions
static dof_id_type	compute_key (dof_id_type n0)
static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1)
static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1, dof_id_type n2)
static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1, dof_id_type n2, dof_id_type n3)
Protected Attributes
Node *	_nodelinks_data [5]
Elem *	_elemlinks_data [6+(LIBMESH_DIM >3)]
Node **	_nodes
Elem **	_elemlinks
Elem **	_children
subdomain_id_type	_sbd_id
unsigned char	_rflag
unsigned char	_pflag
unsigned char	_p_level
Static Protected Attributes
static Counts	_counts
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true
static bool	_enable_print_counter = true

Detailed Description

The Pyramid5 is an element in 3D composed of 5 nodes. It is numbered with a counter-clockwise base like this:

 * PYRAMID5:
 *           o 4
 *         //|\
 *        // | \
 *       //  |  \
 *    3 o/...|...o 2
 *     ./    |  /
 *    ./     | /
 *   ./      |/
 *  o--------o
 *  0        1
 *
 *

Definition at line 53 of file cell_pyramid5.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

typedef Predicates::multi_predicate libMesh::Elem::Predicate [inherited]

Useful iterator typedefs

Definition at line 1087 of file elem.h.

Member Enumeration Documentation

enum libMesh::Elem::RefinementState [inherited]

Useful ENUM describing the refinement state of an element.

Enumerator:

COARSEN
DO_NOTHING
REFINE
JUST_REFINED
JUST_COARSENED
INACTIVE
COARSEN_INACTIVE
INVALID_REFINEMENTSTATE

Definition at line 845 of file elem.h.

                       { COARSEN = 0,
                         DO_NOTHING,
                         REFINE,
                         JUST_REFINED,
                         JUST_COARSENED,
                         INACTIVE,
                         COARSEN_INACTIVE,
                         INVALID_REFINEMENTSTATE };

Constructor & Destructor Documentation

libMesh::Pyramid5::Pyramid5 ( Elem * p = NULL ) [inline, explicit]

Constructor. By default this element has no parent.

Definition at line 175 of file cell_pyramid5.h.

                          :
  Pyramid(Pyramid5::n_nodes(), p, _nodelinks_data)
{
}

Member Function Documentation

bool libMesh::Elem::active ( ) const [inline, inherited]

Returns:: true if the element is active (i.e. has no active descendants), false otherwise. Note that it suffices to check the first child only. Always returns true if AMR is disabled.

Definition at line 1594 of file elem.h.

References libMesh::Elem::COARSEN_INACTIVE, libMesh::Elem::INACTIVE, and libMesh::Elem::refinement_flag().

{
#ifdef LIBMESH_ENABLE_AMR
  if ((this->refinement_flag() == INACTIVE) ||
      (this->refinement_flag() == COARSEN_INACTIVE))
    return false;
  else
    return true;
#else
  return true;
#endif
}

void libMesh::Elem::active_family_tree	(	std::vector< const Elem * > &	active_family,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the family_tree() member, but only adds the active children. Can be thought of as removing all the inactive elements from the vector created by family_tree, but is implemented more efficiently.

Definition at line 1460 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree(), libMesh::Elem::child(), libMesh::Elem::is_remote(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), and libMesh::Elem::subactive().

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::Elem::active_family_tree(), libMesh::ParmetisPartitioner::build_graph(), and libMesh::Partitioner::set_parent_processor_ids().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    active_family.clear();

  // Add this element to the family tree if it is active
  if (this->active())
    active_family.push_back(this);

  // Otherwise recurse into the element's children.
  // Do not clear the vector any more.
  else
    for (unsigned int c=0; c<this->n_children(); c++)
      if (!this->child(c)->is_remote())
        this->child(c)->active_family_tree (active_family, false);
}

void libMesh::Elem::active_family_tree_by_neighbor	(	std::vector< const Elem * > &	family,
		const Elem *	neighbor,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the active_family_tree() member, but only adds elements which are next to neighbor.

Definition at line 1615 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::child(), libMesh::Elem::has_neighbor(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::Elem::active_family_tree_by_neighbor(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::Elem::find_edge_neighbors(), libMesh::Patch::find_face_neighbors(), libMesh::Elem::find_point_neighbors(), and libMesh::SparsityPattern::Build::operator()().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  // This only makes sense if we're already a neighbor
  if (this->level() >= neighbor_in->level())
    libmesh_assert (this->has_neighbor(neighbor_in));

  // Add an active element to the family tree.
  if (this->active())
    family.push_back(this);

  // Or recurse into an ancestor element's children.
  // Do not clear the vector any more.
  else if (!this->active())
    for (unsigned int c=0; c<this->n_children(); c++)
      {
        Elem *current_child = this->child(c);
        if (current_child != remote_elem && current_child->has_neighbor(neighbor_in))
          current_child->active_family_tree_by_neighbor (family, neighbor_in, false);
      }
}

void libMesh::Elem::active_family_tree_by_side	(	std::vector< const Elem * > &	family,
		const unsigned int	side,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the active_family_tree() member, but only adds elements which are next to side.

Definition at line 1510 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::child(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_remote(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), and libMesh::Elem::subactive().

Referenced by libMesh::Elem::active_family_tree_by_side(), libMesh::BoundaryInfo::build_active_side_list(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::ExodusII_IO_Helper::write_sidesets(), and libMesh::Nemesis_IO_Helper::write_sidesets().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  libmesh_assert_less (s, this->n_sides());

  // Add an active element to the family tree.
  if (this->active())
    family.push_back(this);

  // Or recurse into an ancestor element's children.
  // Do not clear the vector any more.
  else
    for (unsigned int c=0; c<this->n_children(); c++)
      if (!this->child(c)->is_remote() && this->is_child_on_side(c, s))
        this->child(c)->active_family_tree_by_side (family, s, false);
}

void libMesh::Elem::add_child ( Elem * elem ) [inherited]

Adds a child pointer to the array of children of this element. If this is the first child to be added, this method allocates memory in the parent's _children array, otherwise, it just sets the pointer.

Definition at line 1347 of file elem.C.

References libMesh::Elem::_children, libMesh::Elem::n_children(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::set_child().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::LegacyXdrIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::unpack().

{
  if(_children == NULL)
    {
      _children = new Elem*[this->n_children()];

      for (unsigned int c=0; c<this->n_children(); c++)
        this->set_child(c, NULL);
    }

  for (unsigned int c=0; c<this->n_children(); c++)
    {
      if(this->_children[c] == NULL || this->_children[c] == remote_elem)
        {
          libmesh_assert_equal_to (this, elem->parent());
          this->set_child(c, elem);
          return;
        }
    }

  libmesh_error_msg("Error: Tried to add a child to an element with full children array");
}

void libMesh::Elem::add_child	(	Elem *	elem,
		unsigned int	c
	)		`[inherited]`

Adds a new child pointer to the specified index in the array of children of this element. If this is the first child to be added, this method allocates memory in the parent's _children array, otherwise, it just sets the pointer.

Definition at line 1372 of file elem.C.

References libMesh::Elem::_children, libMesh::Elem::child(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::set_child().

{
  if(!this->has_children())
    {
      _children = new Elem*[this->n_children()];

      for (unsigned int i=0; i<this->n_children(); i++)
        this->set_child(i, NULL);
    }

  libmesh_assert (this->_children[c] == NULL || this->child(c) == remote_elem);
  libmesh_assert (elem == remote_elem || this == elem->parent());

  this->set_child(c, elem);
}

void libMesh::DofObject::add_system ( ) [inherited]

Adds an additional system to the DofObject

Definition at line 187 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), and libMesh::DofObject::set_n_systems().

{
  // quick return?
  if (this->n_systems() == 0)
    {
      this->set_n_systems(1);
      return;
    }

  DofObject::index_buffer_t::iterator it = _idx_buf.begin();

  std::advance(it, this->n_systems());

  // this inserts the current vector size at the position for the new system - creating the
  // entry we need for the new system indicating there are 0 variables.
  _idx_buf.insert(it, cast_int<dof_id_type>(_idx_buf.size()));

  // cache this value before we screw it up!
  const unsigned int ns_orig = this->n_systems();

  // incriment the number of systems and the offsets for each of
  // the systems including the new one we just added.
  for (unsigned int i=0; i<ns_orig+1; i++)
    _idx_buf[i]++;

  libmesh_assert_equal_to (this->n_systems(), (ns_orig+1));
  libmesh_assert_equal_to (this->n_vars(ns_orig), 0);
  libmesh_assert_equal_to (this->n_var_groups(ns_orig), 0);
}

bool libMesh::Elem::ancestor ( ) const [inherited]

Returns:: true if the element is an ancestor (i.e. has an active child or ancestor child), false otherwise. Always returns false if AMR is disabled.

Definition at line 1325 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::child(), and libMesh::Elem::has_children().

Referenced by libMesh::Elem::ancestor(), libMesh::UnstructuredMesh::contract(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshRefinement::make_coarsening_compatible(), and libMesh::Elem::refine().

{
#ifdef LIBMESH_ENABLE_AMR

  if (this->active())
    return false;

  if (!this->has_children())
    return false;
  if (this->child(0)->active())
    return true;

  return this->child(0)->ancestor();
#else
  return false;
#endif
}

Elem::side_iterator libMesh::Elem::boundary_sides_begin ( ) [inherited]

Iterator accessor functions

Definition at line 2157 of file elem.C.

References libMesh::Elem::_first_side(), and libMesh::Elem::_last_side().

{
  Predicates::BoundarySide<SideIter> bsp;
  return side_iterator(this->_first_side(), this->_last_side(), bsp);
}

Elem::side_iterator libMesh::Elem::boundary_sides_end ( ) [inherited]

Definition at line 2166 of file elem.C.

References libMesh::Elem::_last_side().

{
  Predicates::BoundarySide<SideIter> bsp;
  return side_iterator(this->_last_side(), this->_last_side(), bsp);
}

UniquePtr< Elem > libMesh::Elem::build	(	const ElemType	type,
		Elem *	p = `NULL`
	)		`[static, inherited]`

Build an element of type type. Since this method allocates memory the new Elem is returned in a UniquePtr<>

Definition at line 212 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, and libMesh::TRI6.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::GmshIO::read_mesh(), libMesh::LegacyXdrIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), libMesh::Parallel::unpack(), and libMesh::GMVIO::write_ascii_old_impl().

{
  Elem* elem = NULL;

  switch (type)
    {
      // 0D elements
    case NODEELEM:
      {
        elem = new NodeElem(p);
        break;
      }

      // 1D elements
    case EDGE2:
      {
        elem = new Edge2(p);
        break;
      }
    case EDGE3:
      {
        elem = new Edge3(p);
        break;
      }
    case EDGE4:
      {
        elem = new Edge4(p);
        break;
      }



      // 2D elements
    case TRI3:
      {
        elem = new Tri3(p);
        break;
      }
    case TRI3SUBDIVISION:
      {
        elem = new Tri3Subdivision(p);
        break;
      }
    case TRI6:
      {
        elem = new Tri6(p);
        break;
      }
    case QUAD4:
      {
        elem = new Quad4(p);
        break;
      }
    case QUAD8:
      {
        elem = new Quad8(p);
        break;
      }
    case QUAD9:
      {
        elem = new Quad9(p);
        break;
      }


      // 3D elements
    case TET4:
      {
        elem = new Tet4(p);
        break;
      }
    case TET10:
      {
        elem = new Tet10(p);
        break;
      }
    case HEX8:
      {
        elem = new Hex8(p);
        break;
      }
    case HEX20:
      {
        elem = new Hex20(p);
        break;
      }
    case HEX27:
      {
        elem = new Hex27(p);
        break;
      }
    case PRISM6:
      {
        elem = new Prism6(p);
        break;
      }
    case PRISM15:
      {
        elem = new Prism15(p);
        break;
      }
    case PRISM18:
      {
        elem = new Prism18(p);
        break;
      }
    case PYRAMID5:
      {
        elem = new Pyramid5(p);
        break;
      }
    case PYRAMID13:
      {
        elem = new Pyramid13(p);
        break;
      }
    case PYRAMID14:
      {
        elem = new Pyramid14(p);
        break;
      }



#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

      // 1D infinite elements
    case INFEDGE2:
      {
        elem = new InfEdge2(p);
        break;
      }


      // 2D infinite elements
    case INFQUAD4:
      {
        elem = new InfQuad4(p);
        break;
      }
    case INFQUAD6:
      {
        elem = new InfQuad6(p);
        break;
      }


      // 3D infinite elements
    case INFHEX8:
      {
        elem = new InfHex8(p);
        break;
      }
    case INFHEX16:
      {
        elem = new InfHex16(p);
        break;
      }
    case INFHEX18:
      {
        elem = new InfHex18(p);
        break;
      }
    case INFPRISM6:
      {
        elem = new InfPrism6(p);
        break;
      }
    case INFPRISM12:
      {
        elem = new InfPrism12(p);
        break;
      }

#endif

    default:
      libmesh_error_msg("ERROR: Undefined element type!");
    }

  return UniquePtr<Elem>(elem);
}

UniquePtr< Elem > libMesh::Pyramid5::build_edge ( const unsigned int i ) const [virtual]

Builds a EDGE2 built coincident with edge i. The UniquePtr<Elem> handles the memory aspect.

Implements libMesh::Elem.

Definition at line 203 of file cell_pyramid5.C.

References libMesh::Pyramid::n_edges().

{
  libmesh_assert_less (i, this->n_edges());

  return UniquePtr<Elem>(new SideEdge<Edge2,Pyramid5>(this,i));
}

UniquePtr< Elem > libMesh::Pyramid5::build_side	(	const unsigned int	i,
		bool	proxy
	)		const `[virtual]`

Builds a QUAD4 or TRI3 built coincident with face i. The UniquePtr<Elem> handles the memory aspect.

Implements libMesh::Elem.

Definition at line 108 of file cell_pyramid5.C.

References libMesh::Elem::get_node(), libMesh::Pyramid::n_sides(), libMesh::Elem::set_node(), and libMesh::Elem::subdomain_id().

{
  libmesh_assert_less (i, this->n_sides());

  if (proxy)
    {
      switch (i)
        {
        case 0:
        case 1:
        case 2:
        case 3:
          return UniquePtr<Elem>(new Side<Tri3,Pyramid5>(this,i));

        case 4:
          return UniquePtr<Elem>(new Side<Quad4,Pyramid5>(this,i));

        default:
          libmesh_error_msg("Invalid side i = " << i);
        }
    }

  else
    {
      // Create NULL pointer to be initialized, returned later.
      Elem* face = NULL;

      switch (i)
        {
        case 0:  // triangular face 1
          {
            face = new Tri3;

            face->set_node(0) = this->get_node(0);
            face->set_node(1) = this->get_node(1);
            face->set_node(2) = this->get_node(4);

            break;
          }
        case 1:  // triangular face 2
          {
            face = new Tri3;

            face->set_node(0) = this->get_node(1);
            face->set_node(1) = this->get_node(2);
            face->set_node(2) = this->get_node(4);

            break;
          }
        case 2:  // triangular face 3
          {
            face = new Tri3;

            face->set_node(0) = this->get_node(2);
            face->set_node(1) = this->get_node(3);
            face->set_node(2) = this->get_node(4);

            break;
          }
        case 3:  // triangular face 4
          {
            face = new Tri3;

            face->set_node(0) = this->get_node(3);
            face->set_node(1) = this->get_node(0);
            face->set_node(2) = this->get_node(4);

            break;
          }
        case 4:  // the quad face at z=0
          {
            face = new Quad4;

            face->set_node(0) = this->get_node(0);
            face->set_node(1) = this->get_node(3);
            face->set_node(2) = this->get_node(2);
            face->set_node(3) = this->get_node(1);

            break;
          }
        default:
          libmesh_error_msg("Invalid side i = " << i);
        }

      face->subdomain_id() = this->subdomain_id();
      return UniquePtr<Elem>(face);
    }

  libmesh_error_msg("We'll never get here!");
  return UniquePtr<Elem>();
}

Point libMesh::Elem::centroid ( ) const [virtual, inherited]

Returns:: the centriod of the element. The centroid is computed as the average of all the element vertices. This method is overloadable since some derived elements might want to use shortcuts to compute their centroid.

Definition at line 405 of file elem.C.

References libMesh::TypeVector< T >::add(), and libMesh::Elem::n_vertices().

Referenced by libMesh::SFCPartitioner::_do_partition(), libMesh::MeshCommunication::assign_global_indices(), libMesh::CentroidPartitioner::compute_centroids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::LocationMap< T >::point_of(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::Prism6::volume(), and libMesh::Hex8::volume().

{
  Point cp;

  for (unsigned int n=0; n<this->n_vertices(); n++)
    cp.add (this->point(n));

  return (cp /= static_cast<Real>(this->n_vertices()));
}

Elem * libMesh::Elem::child ( const unsigned int i ) const [inline, inherited]

Returns:: a pointer to the $i^{th}$ child for this element. Do not call if this element has no children, i.e. is active.

Definition at line 1812 of file elem.h.

References libMesh::Elem::_children, and libMesh::libmesh_assert().

Referenced by libMesh::Elem::active_family_tree(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::add_child(), libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::ancestor(), libMesh::Elem::coarsen(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::Elem::family_tree(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::has_ancestor_children(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::Elem::replace_child(), libMesh::Elem::set_p_level(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::MeshTools::Modification::smooth(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Elem::total_family_tree(), libMesh::Parallel::unpack(), libMesh::Elem::which_child_am_i(), and libMesh::XdrIO::write_serialized_connectivity().

{
  libmesh_assert(_children);
  libmesh_assert(_children[i]);

  return _children[i];
}

Elem * libMesh::Elem::child_neighbor ( Elem * elem ) const [inline, inherited]

If the element elem in question is a neighbor of a child of this element, this returns a pointer to that child. Otherwise it returns NULL.

Definition at line 1485 of file elem.h.

References libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor(), and libMesh::Elem::parent().

{
  for (unsigned int n=0; n<elem->n_neighbors(); n++)
    if (elem->neighbor(n) &&
        elem->neighbor(n)->parent() == this)
      return elem->neighbor(n);

  return NULL;
}

const Elem * libMesh::Elem::child_neighbor ( const Elem * elem ) const [inline, inherited]

If the element elem in question is a neighbor of a child of this element, this returns a pointer to that child. Otherwise it returns NULL.

Definition at line 1498 of file elem.h.

References libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor(), and libMesh::Elem::parent().

{
  for (unsigned int n=0; n<elem->n_neighbors(); n++)
    if (elem->neighbor(n) &&
        elem->neighbor(n)->parent() == this)
      return elem->neighbor(n);

  return NULL;
}

void libMesh::DofObject::clear_dofs ( ) [inline, inherited]

Clear the DofMap data structures and return to a pristine state.

Definition at line 585 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::libmesh_assert(), and libMesh::DofObject::n_systems().

Referenced by libMesh::DofObject::set_n_systems(), and libMesh::DofObject::~DofObject().

{
  // vector swap trick to force deallocation
  index_buffer_t().swap(_idx_buf);

  libmesh_assert_equal_to (this->n_systems(), 0);
  libmesh_assert (_idx_buf.empty());
}

void libMesh::DofObject::clear_old_dof_object ( ) [inherited]

Sets the old_dof_object to NULL

Definition at line 134 of file dof_object.C.

References libMesh::DofObject::old_dof_object.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::set_old_dof_object(), libMesh::DofObject::unpack_indexing(), and libMesh::DofObject::~DofObject().

{
  delete this->old_dof_object;
  this->old_dof_object = NULL;
}

bool libMesh::Elem::close_to_point	(	const Point &	p,
		Real	tol
	)		const `[virtual, inherited]`

Returns:: true if this element is "close" to the point p, where "close" is determined by the tolerance tol.

Definition at line 1747 of file elem.C.

References libMesh::Elem::point_test().

{
  // This test uses the user's passed-in tolerance for the
  // bounding box test as well, thereby allowing the routine to
  // find points which are not only "in" the element, but also
  // "nearby" to within some tolerance.
  return this->point_test(p, tol, tol);
}

void libMesh::Elem::coarsen ( ) [inherited]

Coarsen the element. This is not virtual since it is the same for all element types.

Definition at line 149 of file elem_refinement.C.

References libMesh::Elem::active(), libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::child(), libMesh::Elem::COARSEN, libMesh::Elem::COARSEN_INACTIVE, libMesh::Elem::embedding_matrix(), libMesh::Elem::get_node(), libMesh::Elem::INACTIVE, libMesh::Elem::JUST_COARSENED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_nodes(), libMesh::Elem::p_level(), libMesh::Elem::point(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::Elem::set_p_level(), and libMesh::Elem::set_refinement_flag().

Referenced by libMesh::MeshRefinement::_coarsen_elements().

{
  libmesh_assert_equal_to (this->refinement_flag(), Elem::COARSEN_INACTIVE);
  libmesh_assert (!this->active());

  // We no longer delete children until MeshRefinement::contract()
  // delete [] _children;
  // _children = NULL;

  unsigned int parent_p_level = 0;

  // re-compute hanging node nodal locations
  for (unsigned int c=0; c<this->n_children(); c++)
    {
      Elem *mychild = this->child(c);
      if (mychild == remote_elem)
        continue;
      for (unsigned int nc=0; nc<mychild->n_nodes(); nc++)
        {
          Point new_pos;
          bool calculated_new_pos = false;

          for (unsigned int n=0; n<this->n_nodes(); n++)
            {
              // The value from the embedding matrix
              const float em_val = this->embedding_matrix(c,nc,n);

              // The node location is somewhere between existing vertices
              if ((em_val != 0.) && (em_val != 1.))
                {
                  new_pos.add_scaled (this->point(n), em_val);
                  calculated_new_pos = true;
                }
            }

          if(calculated_new_pos)
            {
              //Move the existing node back into it's original location
              for(unsigned int i=0; i<LIBMESH_DIM; i++)
                {
                  Point & child_node = *(mychild->get_node(nc));
                  child_node(i)=new_pos(i);
                }
            }
        }
    }

  for (unsigned int c=0; c<this->n_children(); c++)
    {
      Elem *mychild = this->child(c);
      if (mychild == remote_elem)
        continue;
      libmesh_assert_equal_to (mychild->refinement_flag(), Elem::COARSEN);
      mychild->set_refinement_flag(Elem::INACTIVE);
      if (mychild->p_level() > parent_p_level)
        parent_p_level = mychild->p_level();
    }

  this->set_refinement_flag(Elem::JUST_COARSENED);
  this->set_p_level(parent_p_level);

  libmesh_assert (this->active());
}

dof_id_type libMesh::Elem::compute_key ( dof_id_type n0 ) [inline, static, protected, inherited]

Compute a key from the specified nodes.

Definition at line 1946 of file elem.h.

Referenced by libMesh::Tet::key(), libMesh::Prism::key(), libMesh::Pyramid::key(), libMesh::Hex::key(), libMesh::Tri::key(), libMesh::InfPrism::key(), libMesh::InfHex::key(), libMesh::Quad::key(), libMesh::InfQuad::key(), libMesh::Edge::key(), libMesh::Quad9::key(), libMesh::Tri6::key(), libMesh::Quad8::key(), libMesh::Hex27::key(), libMesh::Prism18::key(), and libMesh::InfHex18::key().

{
  return n0;
}

dof_id_type libMesh::Elem::compute_key	(	dof_id_type	n0,
		dof_id_type	n1
	)		`[inline, static, protected, inherited]`

Compute a key from the specified nodes.

Definition at line 1954 of file elem.h.

References libMesh::Utility::hashword2(), and libMesh::swap().

{
  // Order the two so that n0 < n1
  if (n0 > n1) std::swap (n0, n1);

  return Utility::hashword2(n0, n1);
}

dof_id_type libMesh::Elem::compute_key	(	dof_id_type	n0,
		dof_id_type	n1,
		dof_id_type	n2
	)		`[inline, static, protected, inherited]`

Compute a key from the specified nodes.

Definition at line 1966 of file elem.h.

References libMesh::Utility::hashword(), libMesh::libmesh_assert(), and libMesh::swap().

{
  // Order the numbers such that n0 < n1 < n2.
  // We'll do it in 3 steps like this:
  //
  //     n0         n1                n2
  //     min(n0,n1) max(n0,n1)        n2
  //     min(n0,n1) min(n2,max(n0,n1) max(n2,max(n0,n1)
  //           |\   /|                  |
  //           | \ / |                  |
  //           |  /  |                  |
  //           | /  \|                  |
  //  gb min= min   max              gb max

  // Step 1
  if (n0 > n1) std::swap (n0, n1);

  // Step 2
  if (n1 > n2) std::swap (n1, n2);

  // Step 3
  if (n0 > n1) std::swap (n0, n1);

  libmesh_assert ((n0 < n1) && (n1 < n2));

  dof_id_type array[3] = {n0, n1, n2};
  return Utility::hashword(array, 3);
}

dof_id_type libMesh::Elem::compute_key	(	dof_id_type	n0,
		dof_id_type	n1,
		dof_id_type	n2,
		dof_id_type	n3
	)		`[inline, static, protected, inherited]`

Compute a key from the specified nodes.

Definition at line 2000 of file elem.h.

References libMesh::Utility::hashword(), libMesh::libmesh_assert(), and libMesh::swap().

{
  // Sort first
  // Step 1
  if (n0 > n1) std::swap (n0, n1);

  // Step 2
  if (n2 > n3) std::swap (n2, n3);

  // Step 3
  if (n0 > n2) std::swap (n0, n2);

  // Step 4
  if (n1 > n3) std::swap (n1, n3);

  // Finally sort step 5
  if (n1 > n2) std::swap (n1, n2);

  libmesh_assert ((n0 < n1) && (n1 < n2) && (n2 < n3));

  dof_id_type array[4] = {n0, n1, n2, n3};
  return Utility::hashword(array, 4);
}

void libMesh::Pyramid5::connectivity	(	const unsigned int	sc,
		const IOPackage	iop,
		std::vector< dof_id_type > &	conn
	)		const `[virtual]`

Returns the connectivity for this element in a specific format, which is specified by the IOPackage tag. This method supercedes the tecplot_connectivity(...) and vtk_connectivity(...) routines.

Implements libMesh::Elem.

Definition at line 212 of file cell_pyramid5.C.

References libMesh::Elem::_nodes, libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), n_sub_elem(), libMesh::Elem::node(), libMesh::TECPLOT, and libMesh::VTK.

{
  libmesh_assert(_nodes);
  libmesh_assert_less (sc, this->n_sub_elem());
  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);

  switch (iop)
    {
    case TECPLOT:
      {
        conn.resize(8);
        conn[0] = this->node(0)+1;
        conn[1] = this->node(1)+1;
        conn[2] = this->node(2)+1;
        conn[3] = this->node(3)+1;
        conn[4] = this->node(4)+1;
        conn[5] = this->node(4)+1;
        conn[6] = this->node(4)+1;
        conn[7] = this->node(4)+1;
        return;
      }

    case VTK:
      {
        conn.resize(5);
        conn[0] = this->node(3);
        conn[1] = this->node(2);
        conn[2] = this->node(1);
        conn[3] = this->node(0);
        conn[4] = this->node(4);
        return;
      }

    default:
      libmesh_error_msg("Unsupported IO package " << iop);
    }
}

bool libMesh::Elem::contains_edge_of ( const Elem * e ) const [inherited]

This function returns true iff an edge of e is contained in this element. (Internally, this is done by checking whether at least two vertices of e are contained in this element).

Definition at line 593 of file elem.C.

References libMesh::Elem::contains_point(), libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by libMesh::Elem::find_edge_neighbors().

{
  unsigned int num_contained_edges = 0;

  // Our vertices are the first numbered nodes
  for (unsigned int n = 0; n != e->n_vertices(); ++n)
    {
      if (this->contains_point(e->point(n)))
        {
          num_contained_edges++;
          if(num_contained_edges>=2)
            {
              return true;
            }
        }
    }
  return false;
}

bool libMesh::Elem::contains_point	(	const Point &	p,
		Real	tol = `TOLERANCE`
	)		const `[virtual, inherited]`

Returns:: true if the point p is contained in this element, false otherwise.

For linear elements, performs an initial tight bounding box check (as an optimization step) and (if that passes) then uses the user-defined tolerance "tol" in a call to inverse_map() to actually test if the point is in the element. For quadratic elements, the bounding box optimization is skipped, and only the inverse_map() steps are performed.

Note that this routine should not be used to determine if a point is merely "nearby" an element to within some tolerance. For that, use Elem::close_to_point() instead.

Reimplemented in libMesh::InfHex8, libMesh::InfPrism6, and libMesh::InfQuad4.

Definition at line 1722 of file elem.C.

References libMesh::err, libMesh::Elem::point_test(), and libMesh::TOLERANCE.

Referenced by libMesh::Elem::contains_edge_of(), libMesh::Elem::contains_vertex_of(), libMesh::Elem::find_edge_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::PointLocatorTree::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), and libMesh::HPSingularity::select_refinement().

{
  // We currently allow the user to enlarge the bounding box by
  // providing a tol > TOLERANCE (so this routine is identical to
  // Elem::close_to_point()), but print a warning so that the
  // user can eventually switch his code over to calling close_to_point()
  // instead, which is intended to be used for this purpose.
  if ( tol > TOLERANCE )
    {
      libmesh_do_once(libMesh::err
                      << "WARNING: Resizing bounding box to match user-specified tolerance!\n"
                      << "In the future, calls to Elem::contains_point() with tol > TOLERANCE\n"
                      << "will be more optimized, but should not be used\n"
                      << "to search for points 'close to' elements!\n"
                      << "Instead, use Elem::close_to_point() for this purpose.\n"
                      << std::endl;);
      return this->point_test(p, tol, tol);
    }
  else
    return this->point_test(p, TOLERANCE, tol);
}

bool libMesh::Elem::contains_vertex_of ( const Elem * e ) const [inherited]

This function returns true iff a vertex of e is contained in this element

Definition at line 582 of file elem.C.

References libMesh::Elem::contains_point(), libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by libMesh::Elem::find_point_neighbors().

{
  // Our vertices are the first numbered nodes
  for (unsigned int n = 0; n != e->n_vertices(); ++n)
    if (this->contains_point(e->point(n)))
      return true;
  return false;
}

void libMesh::Elem::contract ( ) [inherited]

Contract an active element, i.e. remove pointers to any subactive children. This should only be called via MeshRefinement::contract, which will also remove subactive children from the mesh

Definition at line 215 of file elem_refinement.C.

References libMesh::Elem::_children, libMesh::Elem::active(), libMesh::Elem::DO_NOTHING, libMesh::Elem::JUST_COARSENED, libMesh::libmesh_assert(), libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

Referenced by libMesh::UnstructuredMesh::contract().

{
  // Subactive elements get deleted entirely, not contracted
  libmesh_assert (this->active());

  // Active contracted elements no longer can have children
  delete [] _children;
  _children = NULL;

  if (this->refinement_flag() == Elem::JUST_COARSENED)
    this->set_refinement_flag(Elem::DO_NOTHING);
}

void libMesh::DofObject::debug_buffer ( ) const [inherited]

Print our buffer for debugging.

Definition at line 543 of file dof_object.C.

References libMesh::DofObject::_idx_buf, and libMesh::out.

{
  libMesh::out << " [ ";
  for (unsigned int i=0; i<_idx_buf.size(); i++)
    libMesh::out << _idx_buf[i] << " ";
  libMesh::out << "]\n";
}

Order libMesh::Pyramid5::default_order ( ) const [inline, virtual]

Returns:: FIRST

Implements libMesh::Elem.

Definition at line 111 of file cell_pyramid5.h.

References libMesh::FIRST.

{ return FIRST; }

unsigned int libMesh::Cell::dim ( ) const [inline, virtual, inherited]

Returns:: 3, the dimensionality of the object.

Implements libMesh::Elem.

Definition at line 57 of file cell.h.

{ return 3; }

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  _enable_print_counter = false;
  return;
}

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  _enable_print_counter = false;
  return;
}

dof_id_type libMesh::DofObject::dof_number	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	comp
	)		const `[inline, inherited]`

Returns:: the global degree of freedom number for variable var, component comp for system s associated with this DofObject

When partitioning and DoF numbering have been performed by libMesh, every current DoF on this DofObject will belong to its processor.

Definition at line 797 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::GMVIO::copy_nodal_solution(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::DofObject(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), libMesh::DofMap::old_dof_indices(), libMesh::DofObject::operator=(), libMesh::HPCoarsenTest::select_refinement(), libMesh::DofObject::set_dof_number(), libMesh::DofMap::set_nonlocal_dof_objects(), and libMesh::System::zero_variable().

{
  libmesh_assert_less (s,    this->n_systems());
  libmesh_assert_less (var,  this->n_vars(s));
  libmesh_assert_less (comp, this->n_comp(s,var));

  const unsigned int
    vg            = this->var_to_vg(s,var),
    start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());

  const dof_id_type
    base_idx = _idx_buf[start_idx_sys + 2*vg + 1];

  // if the first component is invalid, they
  // are all invalid
  if (base_idx == invalid_id)
    return invalid_id;

  // otherwise the index is the first component
  // index augemented by the component number
  else
    {
      const unsigned int
        ncg = this->n_comp_group(s,vg),
        vig = this->system_var_to_vg_var(s,vg,var);

      // std::cout << "base_idx, var, vg, vig, ncg, comp="
      // << base_idx << " "
      // << var << " "
      // << vg << " "
      // << vig << " "
      // << ncg << " "
      // << comp << '\n';

      return cast_int<dof_id_type>(base_idx + vig*ncg + comp);
    }
}

float libMesh::Pyramid5::embedding_matrix	(	const unsigned int	,
		const unsigned int	,
		const unsigned int
	)		const `[inline, protected, virtual]`

Matrix used to create the elements children.

Implements libMesh::Elem.

Definition at line 162 of file cell_pyramid5.h.

  { libmesh_not_implemented(); return 0.; }

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

void libMesh::Elem::family_tree	(	std::vector< const Elem * > &	family,
		const bool	reset = `true`
	)		const `[inherited]`

Fills the vector family with the children of this element, recursively. So, calling this method on a twice-refined element will give you the element itself, its direct children, and their children, etc... When the optional parameter reset is true then the vector will be cleared before the element and its descendants are added.

The family tree only includes ancestor and active elements; for subactive elements as well, use total_family_tree.

Definition at line 1417 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::family_tree(), libMesh::Elem::is_remote(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), and libMesh::Elem::subactive().

Referenced by libMesh::Elem::family_tree().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  // Add this element to the family tree.
  family.push_back(this);

  // Recurse into the elements children, if it has them.
  // Do not clear the vector any more.
  if (!this->active())
    for (unsigned int c=0; c<this->n_children(); c++)
      if (!this->child(c)->is_remote())
        this->child(c)->family_tree (family, false);
}

void libMesh::Elem::family_tree_by_neighbor	(	std::vector< const Elem * > &	family,
		const Elem *	neighbor,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the family_tree() member, but only adds elements which are next to neighbor.

Definition at line 1537 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::has_neighbor(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::Elem::family_tree_by_neighbor(), and libMesh::Elem::make_links_to_me_remote().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  // This only makes sense if we're already a neighbor
  libmesh_assert (this->has_neighbor(neighbor_in));

  // Add this element to the family tree.
  family.push_back(this);

  // Recurse into the elements children, if it's not active.
  // Do not clear the vector any more.
  if (!this->active())
    for (unsigned int c=0; c<this->n_children(); c++)
      {
        Elem *current_child = this->child(c);
        if (current_child != remote_elem && current_child->has_neighbor(neighbor_in))
          current_child->family_tree_by_neighbor (family, neighbor_in, false);
      }
}

void libMesh::Elem::family_tree_by_side	(	std::vector< const Elem * > &	family,
		const unsigned int	side,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the family_tree() member, but only adds elements which are next to side.

Definition at line 1484 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_remote(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), and libMesh::Elem::subactive().

Referenced by libMesh::Elem::family_tree_by_side(), and libMesh::Elem::make_links_to_me_local().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  libmesh_assert_less (s, this->n_sides());

  // Add this element to the family tree.
  family.push_back(this);

  // Recurse into the elements children, if it has them.
  // Do not clear the vector any more.
  if (!this->active())
    for (unsigned int c=0; c<this->n_children(); c++)
      if (!this->child(c)->is_remote() && this->is_child_on_side(c, s))
        this->child(c)->family_tree_by_side (family, s, false);
}

void libMesh::Elem::family_tree_by_subneighbor	(	std::vector< const Elem * > &	family,
		const Elem *	neighbor,
		const Elem *	subneighbor,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the family_tree() member, but only adds elements which are next to subneighbor. Only applicable when this->has_neighbor(neighbor) and neighbor->is_ancestor(subneighbor)

Definition at line 1567 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::has_neighbor(), libMesh::Elem::is_ancestor_of(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::Elem::family_tree_by_subneighbor(), and libMesh::Elem::make_links_to_me_remote().

{
  // The "family tree" doesn't include subactive elements
  libmesh_assert(!this->subactive());

  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  // To simplifly this function we need an existing neighbor
  libmesh_assert (neighbor_in);
  libmesh_assert_not_equal_to (neighbor_in, remote_elem);
  libmesh_assert (this->has_neighbor(neighbor_in));

  // This only makes sense if subneighbor descends from neighbor
  libmesh_assert (subneighbor);
  libmesh_assert_not_equal_to (subneighbor, remote_elem);
  libmesh_assert (neighbor_in->is_ancestor_of(subneighbor));

  // Add this element to the family tree if applicable.
  if (neighbor_in == subneighbor)
    family.push_back(this);

  // Recurse into the elements children, if it's not active.
  // Do not clear the vector any more.
  if (!this->active())
    for (unsigned int c=0; c != this->n_children(); ++c)
      {
        Elem *current_child = this->child(c);
        if (current_child != remote_elem)
          for (unsigned int s=0; s != current_child->n_sides(); ++s)
            {
              Elem *child_neigh = current_child->neighbor(s);
              if (child_neigh &&
                  (child_neigh == neighbor_in ||
                   (child_neigh->parent() == neighbor_in &&
                    child_neigh->is_ancestor_of(subneighbor))))
                current_child->family_tree_by_subneighbor (family, child_neigh,
                                                           subneighbor, false);
            }
      }
}

void libMesh::Elem::find_edge_neighbors	(	const Point &	p1,
		const Point &	p2,
		std::set< const Elem * > &	neighbor_set
	)		const `[inherited]`

This function finds all active elements which touch the current active element along the specified edge defined by the two points p1 and p2

Definition at line 767 of file elem.C.

References libMesh::Elem::contains_point(), end, libMesh::Elem::find_point_neighbors(), and libMesh::libmesh_assert().

Referenced by libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement().

{
  // Simple but perhaps suboptimal code: find elements containing the
  // first point, then winnow this set down by removing elements which
  // don't also contain the second point

  libmesh_assert(this->contains_point(p2));
  this->find_point_neighbors(p1, neighbor_set);

  std::set<const Elem*>::iterator        it = neighbor_set.begin();
  const std::set<const Elem*>::iterator end = neighbor_set.end();

  while(it != end) {
    std::set<const Elem*>::iterator current = it++;

    const Elem* elem = *current;
    // This won't invalidate iterator it, because it is already
    // pointing to the next element
    if (!elem->contains_point(p2))
      neighbor_set.erase(current);
  }
}

void libMesh::Elem::find_edge_neighbors ( std::set< const Elem * > & neighbor_set ) const [inherited]

This function finds all active elements which touch the current active element along any edge (more precisely, at at least two points).

Definition at line 794 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::contains_edge_of(), end, libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), and libMesh::remote_elem.

{
  neighbor_set.clear();
  neighbor_set.insert(this);

  std::set<const Elem *> untested_set, next_untested_set;
  untested_set.insert(this);

  while (!untested_set.empty())
    {
      // Loop over all the elements in the patch that haven't already
      // been tested
      std::set<const Elem*>::const_iterator       it  = untested_set.begin();
      const std::set<const Elem*>::const_iterator end = untested_set.end();

      for (; it != end; ++it)
        {
          const Elem* elem = *it;

          for (unsigned int s=0; s<elem->n_sides(); s++)
            {
              const Elem* current_neighbor = elem->neighbor(s);
              if (current_neighbor &&
                  current_neighbor != remote_elem)    // we have a real neighbor on this side
                {
                  if (current_neighbor->active())                // ... if it is active
                    {
                      if (this->contains_edge_of(current_neighbor) // ... and touches us
                          || current_neighbor->contains_edge_of(this))
                        {
                          // Make sure we'll test it
                          if (!neighbor_set.count(current_neighbor))
                            next_untested_set.insert (current_neighbor);

                          // And add it
                          neighbor_set.insert (current_neighbor);
                        }
                    }
#ifdef LIBMESH_ENABLE_AMR
                  else                                 // ... the neighbor is *not* active,
                    {                                  // ... so add *all* neighboring
                                                       // active children
                      std::vector<const Elem*> active_neighbor_children;

                      current_neighbor->active_family_tree_by_neighbor
                        (active_neighbor_children, elem);

                      std::vector<const Elem*>::const_iterator
                        child_it = active_neighbor_children.begin();
                      const std::vector<const Elem*>::const_iterator
                        child_end = active_neighbor_children.end();
                      for (; child_it != child_end; ++child_it)
                        {
                          const Elem *current_child = *child_it;
                          if (this->contains_edge_of(*child_it) ||
                              (*child_it)->contains_edge_of(this))
                            {
                              // Make sure we'll test it
                              if (!neighbor_set.count(current_child))
                                next_untested_set.insert (current_child);

                              neighbor_set.insert (current_child);
                            }
                        }
                    }
#endif // #ifdef LIBMESH_ENABLE_AMR
                }
            }
        }
      untested_set.swap(next_untested_set);
      next_untested_set.clear();
    }
}

void libMesh::Elem::find_point_neighbors	(	const Point &	p,
		std::set< const Elem * > &	neighbor_set
	)		const `[inherited]`

This function finds all elements (including this one) which touch the current active element at the specified point, which should be a point in the current element.

Definition at line 614 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::contains_point(), end, libMesh::libmesh_assert(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), and libMesh::remote_elem.

Referenced by libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::Elem::find_edge_neighbors(), libMesh::MeshFunction::find_element(), libMesh::Patch::find_point_neighbors(), and libMesh::Elem::is_semilocal().

{
  libmesh_assert(this->contains_point(p));

  neighbor_set.clear();
  neighbor_set.insert(this);

  std::set<const Elem *> untested_set, next_untested_set;
  untested_set.insert(this);

  while (!untested_set.empty())
    {
      // Loop over all the elements in the patch that haven't already
      // been tested
      std::set<const Elem*>::const_iterator       it  = untested_set.begin();
      const std::set<const Elem*>::const_iterator end = untested_set.end();

      for (; it != end; ++it)
        {
          const Elem* elem = *it;

          for (unsigned int s=0; s<elem->n_sides(); s++)
            {
              const Elem* current_neighbor = elem->neighbor(s);
              if (current_neighbor &&
                  current_neighbor != remote_elem)    // we have a real neighbor on this side
                {
                  if (current_neighbor->active())                // ... if it is active
                    {
                      if (current_neighbor->contains_point(p))   // ... and touches p
                        {
                          // Make sure we'll test it
                          if (!neighbor_set.count(current_neighbor))
                            next_untested_set.insert (current_neighbor);

                          // And add it
                          neighbor_set.insert (current_neighbor);
                        }
                    }
#ifdef LIBMESH_ENABLE_AMR
                  else                                 // ... the neighbor is *not* active,
                    {                                  // ... so add *all* neighboring
                                                       // active children that touch p
                      std::vector<const Elem*> active_neighbor_children;

                      current_neighbor->active_family_tree_by_neighbor
                        (active_neighbor_children, elem);

                      std::vector<const Elem*>::const_iterator
                        child_it = active_neighbor_children.begin();
                      const std::vector<const Elem*>::const_iterator
                        child_end = active_neighbor_children.end();
                      for (; child_it != child_end; ++child_it)
                        {
                          const Elem *current_child = *child_it;
                          if (current_child->contains_point(p))
                            {
                              // Make sure we'll test it
                              if (!neighbor_set.count(current_child))
                                next_untested_set.insert (current_child);

                              neighbor_set.insert (current_child);
                            }
                        }
                    }
#endif // #ifdef LIBMESH_ENABLE_AMR
                }
            }
        }
      untested_set.swap(next_untested_set);
      next_untested_set.clear();
    }
}

void libMesh::Elem::find_point_neighbors ( std::set< const Elem * > & neighbor_set ) const [inherited]

This function finds all elements (including this one) which touch the current element at any point

Definition at line 691 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::contains_vertex_of(), end, libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), and libMesh::remote_elem.

{
  neighbor_set.clear();
  neighbor_set.insert(this);

  std::set<const Elem *> untested_set, next_untested_set;
  untested_set.insert(this);

  while (!untested_set.empty())
    {
      // Loop over all the elements in the patch that haven't already
      // been tested
      std::set<const Elem*>::const_iterator       it  = untested_set.begin();
      const std::set<const Elem*>::const_iterator end = untested_set.end();

      for (; it != end; ++it)
        {
          const Elem* elem = *it;

          for (unsigned int s=0; s<elem->n_sides(); s++)
            {
              const Elem* current_neighbor = elem->neighbor(s);
              if (current_neighbor &&
                  current_neighbor != remote_elem)    // we have a real neighbor on this side
                {
                  if (current_neighbor->active())                // ... if it is active
                    {
                      if (this->contains_vertex_of(current_neighbor) // ... and touches us
                          || current_neighbor->contains_vertex_of(this))
                        {
                          // Make sure we'll test it
                          if (!neighbor_set.count(current_neighbor))
                            next_untested_set.insert (current_neighbor);

                          // And add it
                          neighbor_set.insert (current_neighbor);
                        }
                    }
#ifdef LIBMESH_ENABLE_AMR
                  else                                 // ... the neighbor is *not* active,
                    {                                  // ... so add *all* neighboring
                                                       // active children
                      std::vector<const Elem*> active_neighbor_children;

                      current_neighbor->active_family_tree_by_neighbor
                        (active_neighbor_children, elem);

                      std::vector<const Elem*>::const_iterator
                        child_it = active_neighbor_children.begin();
                      const std::vector<const Elem*>::const_iterator
                        child_end = active_neighbor_children.end();
                      for (; child_it != child_end; ++child_it)
                        {
                          const Elem *current_child = *child_it;
                          if (this->contains_vertex_of(current_child) ||
                              (current_child)->contains_vertex_of(this))
                            {
                              // Make sure we'll test it
                              if (!neighbor_set.count(current_child))
                                next_untested_set.insert (current_child);

                              neighbor_set.insert (current_child);
                            }
                        }
                    }
#endif // #ifdef LIBMESH_ENABLE_AMR
                }
            }
        }
      untested_set.swap(next_untested_set);
      next_untested_set.clear();
    }
}

ElemType libMesh::Elem::first_order_equivalent_type ( const ElemType et ) [static, inherited]

Returns:: the element type of the associated first-order element, e.g. when this is a TET10, then TET4 is returned. Returns INVALID_ELEM for first order or other elements that should not or cannot be converted into lower order equivalents.

Definition at line 1991 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::INVALID_ELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::GMVIO::write_ascii_old_impl().

{
  switch (et)
    {
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return EDGE2;
    case TRI3:
    case TRI6:
      return TRI3;
    case QUAD4:
    case QUAD8:
    case QUAD9:
      return QUAD4;
    case TET4:
    case TET10:
      return TET4;
    case HEX8:
    case HEX27:
    case HEX20:
      return HEX8;
    case PRISM6:
    case PRISM15:
    case PRISM18:
      return PRISM6;
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
      return PYRAMID5;

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

    case INFQUAD4:
    case INFQUAD6:
      return INFQUAD4;
    case INFHEX8:
    case INFHEX16:
    case INFHEX18:
      return INFHEX8;
    case INFPRISM6:
    case INFPRISM12:
      return INFPRISM6;

#endif

    default:
      // unknown element
      return INVALID_ELEM;
    }
}

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

std::string libMesh::Elem::get_info ( ) const [inherited]

Prints relevant information about the element to a string.

Definition at line 1870 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::Utility::enum_to_string(), libMesh::Elem::get_node(), libMesh::Elem::has_children(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::infinite(), libMesh::Elem::level(), libMesh::DofObject::n_comp(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::Elem::neighbor(), libMesh::Elem::origin(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::Elem::subactive(), libMesh::Elem::type(), libMesh::DofObject::valid_id(), and libMesh::Elem::volume().

Referenced by libMesh::Elem::print_info().

{
  std::ostringstream oss;

  oss << "  Elem Information"                                      << '\n'
      << "   id()=";

  if (this->valid_id())
    oss << this->id();
  else
    oss << "invalid";

  oss << ", processor_id()=" << this->processor_id()               << '\n';

  oss << "   type()="    << Utility::enum_to_string(this->type())  << '\n'
      << "   dim()="     << this->dim()                            << '\n'
      << "   n_nodes()=" << this->n_nodes()                        << '\n';

  for (unsigned int n=0; n != this->n_nodes(); ++n)
    oss << "    " << n << *this->get_node(n);

  oss << "   n_sides()=" << this->n_sides()                        << '\n';

  for (unsigned int s=0; s != this->n_sides(); ++s)
    {
      oss << "    neighbor(" << s << ")=";
      if (this->neighbor(s))
        oss << this->neighbor(s)->id() << '\n';
      else
        oss << "NULL\n";
    }

  oss << "   hmin()=" << this->hmin()
      << ", hmax()=" << this->hmax()                               << '\n'
      << "   volume()=" << this->volume()                          << '\n'
      << "   active()=" << this->active()
      << ", ancestor()=" << this->ancestor()
      << ", subactive()=" << this->subactive()
      << ", has_children()=" << this->has_children()               << '\n'
      << "   parent()=";
  if (this->parent())
    oss << this->parent()->id() << '\n';
  else
    oss << "NULL\n";
  oss << "   level()=" << this->level()
      << ", p_level()=" << this->p_level()                         << '\n'
#ifdef LIBMESH_ENABLE_AMR
      << "   refinement_flag()=" << Utility::enum_to_string(this->refinement_flag())        << '\n'
      << "   p_refinement_flag()=" << Utility::enum_to_string(this->p_refinement_flag())    << '\n'
#endif
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      << "   infinite()=" << this->infinite()    << '\n';
  if (this->infinite())
    oss << "   origin()=" << this->origin()    << '\n'
#endif
      ;

  oss << "   DoFs=";
  for (unsigned int s=0; s != this->n_systems(); ++s)
    for (unsigned int v=0; v != this->n_vars(s); ++v)
      for (unsigned int c=0; c != this->n_comp(s,v); ++c)
        oss << '(' << s << '/' << v << '/' << this->dof_number(s,v,c) << ") ";


  return oss.str();
}

Node * libMesh::Elem::get_node ( const unsigned int i ) const [inline, inherited]

Returns:: the pointer to local Node i.

Reimplemented in libMesh::RemoteElem.

Definition at line 1404 of file elem.h.

References libMesh::Elem::_nodes, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);

  return _nodes[i];
}

unsigned int libMesh::Elem::get_node_index ( const Node * node_ptr ) const [inline, inherited]

Returns:: the local index for the Node pointer node_ptr, or invalid_id if node_ptr is not a local node.

Definition at line 1415 of file elem.h.

References libMesh::Elem::_nodes, libMesh::invalid_uint, and libMesh::Elem::n_nodes().

Referenced by libMesh::ElemCutter::find_intersection_points().

{
  for (unsigned int n=0; n != this->n_nodes(); ++n)
    if (this->_nodes[n] == node_ptr)
      return n;

  return libMesh::invalid_uint;
}

const Node *const * libMesh::Elem::get_nodes ( ) const [inline, inherited]

Returns:: a pointer to an array of local node pointers.

Definition at line 1396 of file elem.h.

References libMesh::Elem::_nodes.

Referenced by libMesh::DofMap::dof_indices().

{
  return _nodes;
}

void libMesh::Elem::hack_p_level ( const unsigned int p ) [inline, inherited]

Sets the value of the p refinement level for the element without altering the p level of its ancestors

Definition at line 1935 of file elem.h.

References libMesh::Elem::_p_level.

Referenced by libMesh::CheckpointIO::read_connectivity(), and libMesh::XdrIO::read_serialized_connectivity().

{
  _p_level = cast_int<unsigned char>(p);
}

bool libMesh::Pyramid5::has_affine_map ( ) const [virtual]

Returns:: true iff the element map is definitely affine (i.e. the same at every quadrature point) within numerical tolerances

Reimplemented from libMesh::Elem.

Definition at line 99 of file cell_pyramid5.C.

{
  //  Point v = this->point(3) - this->point(0);
  //  return (v.relative_fuzzy_equals(this->point(2) - this->point(1)));
  return false;
}

bool libMesh::Elem::has_ancestor_children ( ) const [inline, inherited]

Returns:: true if the element has any descendants other than its immediate children, false otherwise. Always returns false if AMR is disabled.

Definition at line 1646 of file elem.h.

References libMesh::Elem::_children, libMesh::Elem::child(), libMesh::Elem::has_children(), and libMesh::Elem::n_children().

{
#ifdef LIBMESH_ENABLE_AMR
  if (_children == NULL)
    return false;
  else
    for (unsigned int c=0; c != this->n_children(); c++)
      if (this->child(c)->has_children())
        return true;
#endif
  return false;
}

bool libMesh::Elem::has_children ( ) const [inline, inherited]

Returns:: true if the element has any children (active or not), false otherwise. Always returns false if AMR is disabled.

Definition at line 1632 of file elem.h.

References libMesh::Elem::_children.

Referenced by libMesh::Elem::add_child(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::ancestor(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::get_info(), libMesh::Elem::has_ancestor_children(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::Elem::replace_child(), libMesh::Elem::set_child(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Elem::total_family_tree(), and libMesh::Elem::which_child_am_i().

{
#ifdef LIBMESH_ENABLE_AMR
  if (_children == NULL)
    return false;
  else
    return true;
#else
  return false;
#endif
}

bool libMesh::DofObject::has_dofs ( const unsigned int s = libMesh::invalid_uint ) const [inline, inherited]

Returns:: true if any system has variables which have been assigned, false otherwise

Definition at line 842 of file dof_object.h.

References libMesh::invalid_uint, libMesh::DofObject::n_systems(), and libMesh::DofObject::n_vars().

Referenced by libMesh::MeshTools::libmesh_assert_old_dof_objects(), libMesh::DofMap::old_dof_indices(), and libMesh::DofMap::reinit().

{
  if (sys == libMesh::invalid_uint)
    {
      for (unsigned int s=0; s<this->n_systems(); s++)
        if (this->n_vars(s))
          return true;
    }

  else
    {
      libmesh_assert_less (sys, this->n_systems());

      if (this->n_vars(sys))
        return true;
    }

  return false;
}

bool libMesh::Elem::has_neighbor ( const Elem * elem ) const [inline, inherited]

Returns:: true if the element elem in question is a neighbor of this element, false otherwise.

Definition at line 1473 of file elem.h.

References libMesh::Elem::n_neighbors(), and libMesh::Elem::neighbor().

Referenced by libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::has_topological_neighbor(), libMesh::MeshRefinement::has_topological_neighbor(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), and libMesh::Elem::on_boundary().

{
  for (unsigned int n=0; n<this->n_neighbors(); n++)
    if (this->neighbor(n) == elem)
      return true;

  return false;
}

bool libMesh::Elem::has_topological_neighbor	(	const Elem *	elem,
		const MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		PeriodicBoundaries *	pb
	)		const `[inherited]`

Returns:: true if the element elem in question is a neighbor or topological neighbor of this element, false otherwise.

Definition at line 947 of file elem.C.

References libMesh::Elem::has_neighbor(), libMesh::Elem::n_neighbors(), and libMesh::Elem::topological_neighbor().

Referenced by libMesh::MeshRefinement::has_topological_neighbor().

{
  // First see if this is a normal "interior" neighbor
  if (has_neighbor(elem))
    return true;

  for (unsigned int n=0; n<this->n_neighbors(); n++)
    if (this->topological_neighbor(n, mesh, point_locator, pb))
      return true;

  return false;
}

Real libMesh::Elem::hmax ( ) const [virtual, inherited]

Returns:: the maximum vertex separation for the element.

Definition at line 434 of file elem.C.

References std::max(), libMesh::Elem::n_vertices(), libMesh::Elem::point(), libMesh::Real, and libMesh::TypeVector< T >::size_sq().

Referenced by libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::Elem::get_info(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::Elem::point_test().

{
  Real h_max=0;

  for (unsigned int n_outer=0; n_outer<this->n_vertices(); n_outer++)
    for (unsigned int n_inner=n_outer+1; n_inner<this->n_vertices(); n_inner++)
      {
        const Point diff = (this->point(n_outer) - this->point(n_inner));

        h_max = std::max(h_max,diff.size_sq());
      }

  return std::sqrt(h_max);
}

Real libMesh::Elem::hmin ( ) const [virtual, inherited]

Returns:: the minimum vertex separation for the element.

Definition at line 417 of file elem.C.

References std::max(), std::min(), libMesh::Elem::n_vertices(), libMesh::Elem::point(), libMesh::Real, and libMesh::TypeVector< T >::size_sq().

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::FEMSystem::numerical_jacobian(), libMesh::Elem::refine(), and libMesh::SerialMesh::stitching_helper().

{
  Real h_min=std::numeric_limits<Real>::max();

  for (unsigned int n_outer=0; n_outer<this->n_vertices(); n_outer++)
    for (unsigned int n_inner=n_outer+1; n_inner<this->n_vertices(); n_inner++)
      {
        const Point diff = (this->point(n_outer) - this->point(n_inner));

        h_min = std::min(h_min,diff.size_sq());
      }

  return std::sqrt(h_min);
}

dof_id_type libMesh::DofObject::id ( ) const [inline, inherited]

Returns:: the id for this DofObject

Definition at line 619 of file dof_object.h.

References libMesh::DofObject::_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_id().

{
  libmesh_assert (this->valid_id());
  return _id;
}

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

bool libMesh::Cell::infinite ( ) const [inline, virtual, inherited]

Returns:: 4; false. All classes derived from Cell are finite elements.

Implements libMesh::Elem.

Definition at line 71 of file cell.h.

{ return false; }

const Elem * libMesh::Elem::interior_parent ( ) const [inline, inherited]

In some cases it is desireable to extract the boundary (or a subset thereof) of a D-dimensional mesh as a (D-1)-dimensional manifold. In this case we may want to know the 'parent' element from which the manifold elements were extracted. We can easily do that for the level-0 manifold elements by storing the D-dimensional parent. This method provides access to that element.

Definition at line 1725 of file elem.h.

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), libMesh::libmesh_assert(), and libMesh::Elem::n_sides().

{
  // interior parents make no sense for full-dimensional elements.
  libmesh_assert_less (this->dim(), LIBMESH_DIM);

  // // and they [USED TO BE] only good for level-0 elements
  // if (this->level() != 0)
  // return this->parent()->interior_parent();

  // We store the interior_parent pointer after both the parent
  // neighbor and neighbor pointers
  Elem *interior_p = _elemlinks[1+this->n_sides()];

  // If we have an interior_parent, it had better be the
  // one-higher-dimensional interior element we are looking for.
  libmesh_assert (!interior_p ||
                  interior_p->dim() == (this->dim()+1));

  return interior_p;
}

void libMesh::DofObject::invalidate ( ) [inline, inherited]

Invalidates all the indices for this DofObject

Definition at line 575 of file dof_object.h.

References libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), and libMesh::DofObject::invalidate_processor_id().

Referenced by libMesh::DofObject::DofObject().

{
  this->invalidate_dofs ();
  this->invalidate_id ();
  this->invalidate_processor_id ();
}

void libMesh::DofObject::invalidate_dofs ( const unsigned int sys_num = libMesh::invalid_uint ) [inline, inherited]

Sets all degree of freedom numbers to invalid_id

Definition at line 539 of file dof_object.h.

References libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::set_vg_dof_base().

Referenced by libMesh::DofObject::invalidate().

{
  // If the user does not specify the system number...
  if (sys_num >= this->n_systems())
    {
      for (unsigned int s=0; s<this->n_systems(); s++)
        for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
          if (this->n_comp_group(s,vg))
            this->set_vg_dof_base(s,vg,invalid_id);
    }
  // ...otherwise invalidate the dofs for all systems
  else
    for (unsigned int vg=0; vg<this->n_var_groups(sys_num); vg++)
      if (this->n_comp_group(sys_num,vg))
        this->set_vg_dof_base(sys_num,vg,invalid_id);
}

void libMesh::DofObject::invalidate_id ( ) [inline, inherited]

Sets the id to invalid_id

Definition at line 559 of file dof_object.h.

References libMesh::DofObject::invalid_id, and libMesh::DofObject::set_id().

Referenced by libMesh::DofObject::invalidate().

{
  this->set_id (invalid_id);
}

void libMesh::DofObject::invalidate_processor_id ( ) [inline, inherited]

Sets the processor id to invalid_processor_id

Definition at line 567 of file dof_object.h.

References libMesh::DofObject::invalid_processor_id, and libMesh::DofObject::processor_id().

Referenced by libMesh::MeshTools::correct_node_proc_ids(), libMesh::DofObject::invalidate(), libMesh::Partitioner::set_node_processor_ids(), and libMesh::Partitioner::set_parent_processor_ids().

{
  this->processor_id (invalid_processor_id);
}

bool libMesh::Elem::is_ancestor_of ( const Elem * descendant ) const [inline, inherited]

Returns:: true if descendant is a child of this, or a child of a child of this, etc. Always returns false if AMR is disabled.

Definition at line 1662 of file elem.h.

References libMesh::Elem::parent().

Referenced by libMesh::Elem::family_tree_by_subneighbor().

{
#ifdef LIBMESH_ENABLE_AMR
  const Elem *e = descendant;
  while (e)
    {
      if (this == e)
        return true;
      e = e->parent();
    }
#endif
  return false;
}

bool libMesh::Elem::is_child_on_edge	(	const unsigned int	c,
		const unsigned int	e
	)		const `[virtual, inherited]`

Returns:: true iff the specified child is on the specified edge

Definition at line 1401 of file elem.C.

References libMesh::Elem::build_edge(), libMesh::Elem::n_children(), and libMesh::Elem::n_edges().

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::BoundaryInfo::n_edge_boundary_ids().

{
  libmesh_assert_less (c, this->n_children());
  libmesh_assert_less (e, this->n_edges());

  UniquePtr<Elem> my_edge = this->build_edge(e);
  UniquePtr<Elem> child_edge = this->build_edge(e);

  // We're assuming that an overlapping child edge has the same
  // number and orientation as its parent
  return (child_edge->node(0) == my_edge->node(0) ||
          child_edge->node(1) == my_edge->node(1));
}

bool libMesh::Pyramid::is_child_on_side	(	const unsigned int	c,
		const unsigned int	s
	)		const `[virtual, inherited]`

Returns:: true iff the specified child is on the specified side

Implements libMesh::Elem.

Definition at line 154 of file cell_pyramid.C.

References libMesh::Pyramid::n_children(), libMesh::Pyramid::n_sides(), and side_nodes_map.

{
  libmesh_assert_less (c, this->n_children());
  libmesh_assert_less (s, this->n_sides());

  for (unsigned int i = 0; i != 4; ++i)
    if (Pyramid5::side_nodes_map[s][i] == c)
      return true;
  return false;
}

bool libMesh::Pyramid5::is_edge ( const unsigned int i ) const [virtual]

Returns:: true iff the specified (local) node number is an edge.

Implements libMesh::Elem.

Definition at line 67 of file cell_pyramid5.C.

{
  return false;
}

bool libMesh::Pyramid::is_edge_on_side	(	const unsigned int	e,
		const unsigned int	s
	)		const `[virtual, inherited]`

Implements libMesh::Elem.

Definition at line 168 of file cell_pyramid.C.

References edge_nodes_map, libMesh::Elem::is_node_on_side(), libMesh::Pyramid::n_edges(), and libMesh::Pyramid::n_sides().

{
  libmesh_assert_less (e, this->n_edges());
  libmesh_assert_less (s, this->n_sides());

  return (is_node_on_side(Pyramid5::edge_nodes_map[e][0],s) &&
          is_node_on_side(Pyramid5::edge_nodes_map[e][1],s));
}

bool libMesh::Pyramid5::is_face ( const unsigned int i ) const [virtual]

Returns:: true iff the specified (local) node number is a face.

Implements libMesh::Elem.

Definition at line 72 of file cell_pyramid5.C.

{
  return false;
}

virtual bool libMesh::Elem::is_linear ( ) const [inline, virtual, inherited]

Returns:: true iff the Lagrange shape functions on this element are linear

Reimplemented in libMesh::NodeElem, libMesh::Tet4, libMesh::Tri3, libMesh::Edge2, and libMesh::Tri3Subdivision.

Definition at line 667 of file elem.h.

Referenced by libMesh::FEMap::init_reference_to_physical_map().

{ return false; }

bool libMesh::Pyramid5::is_node_on_edge	(	const unsigned int	n,
		const unsigned int	e
	)		const `[virtual]`

Implements libMesh::Elem.

Definition at line 87 of file cell_pyramid5.C.

References edge_nodes_map, and libMesh::Pyramid::n_edges().

{
  libmesh_assert_less (e, n_edges());
  for (unsigned int i = 0; i != 2; ++i)
    if (edge_nodes_map[e][i] == n)
      return true;
  return false;
}

bool libMesh::Pyramid5::is_node_on_side	(	const unsigned int	n,
		const unsigned int	s
	)		const `[virtual]`

Implements libMesh::Elem.

Definition at line 77 of file cell_pyramid5.C.

References libMesh::Pyramid::n_sides(), and side_nodes_map.

{
  libmesh_assert_less (s, n_sides());
  for (unsigned int i = 0; i != 4; ++i)
    if (side_nodes_map[s][i] == n)
      return true;
  return false;
}

virtual bool libMesh::Elem::is_remote ( ) const [inline, virtual, inherited]

Returns true if this element is remote, false otherwise. A remote element (see RemoteElem) is a syntactic convenience -- it is a placeholder for an element which exists on some other processor. Local elements are required to have valid neighbors, and these ghost elements may have remote neighbors for data structure consistency. The use of remote elements helps assure that any element we may access has a NULL neighbor if and only if it lies on the physical boundary of the domain.

Reimplemented in libMesh::RemoteElem.

Definition at line 375 of file elem.h.

Referenced by libMesh::Elem::active_family_tree(), libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::family_tree(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::make_links_to_me_local(), libMesh::Partitioner::set_parent_processor_ids(), and libMesh::Elem::total_family_tree().

  { return false; }

bool libMesh::Elem::is_semilocal ( const processor_id_type my_pid ) const [inherited]

Returns:: true if this element is semilocal to the calling processor, which must specify its rank.

Definition at line 561 of file elem.C.

References end, libMesh::Elem::find_point_neighbors(), and libMesh::DofObject::processor_id().

Referenced by libMesh::Patch::add_semilocal_face_neighbors(), and libMesh::Patch::add_semilocal_point_neighbors().

{
  std::set<const Elem *> point_neighbors;

  this->find_point_neighbors(point_neighbors);

  std::set<const Elem*>::const_iterator       it  = point_neighbors.begin();
  const std::set<const Elem*>::const_iterator end = point_neighbors.end();

  for (; it != end; ++it)
    {
      const Elem* elem = *it;
      if (elem->processor_id() == my_pid)
        return true;
    }

  return false;
}

bool libMesh::Pyramid5::is_vertex ( const unsigned int i ) const [virtual]

Returns:: true iff the specified (local) node number is a vertex.

Implements libMesh::Elem.

Definition at line 62 of file cell_pyramid5.C.

{
  return true;
}

dof_id_type libMesh::Pyramid::key ( const unsigned int s ) const [virtual, inherited]

Returns:: an id associated with the s side of this element. The id is not necessariy unique, but should be close. This is particularly useful in the MeshBase::find_neighbors() routine.

Implements libMesh::Elem.

Definition at line 33 of file cell_pyramid.C.

References libMesh::Elem::compute_key(), libMesh::Pyramid::n_sides(), and libMesh::Elem::node().

{
  libmesh_assert_less (s, this->n_sides());

  switch (s)
    {
    case 0:  // triangular face 1

      return
        this->compute_key (this->node(0),
                           this->node(1),
                           this->node(4));

    case 1:  // triangular face 2

      return
        this->compute_key (this->node(1),
                           this->node(2),
                           this->node(4));

    case 2:  // triangular face 3

      return
        this->compute_key (this->node(2),
                           this->node(3),
                           this->node(4));

    case 3:  // triangular face 4

      return
        this->compute_key (this->node(3),
                           this->node(0),
                           this->node(4));

    case 4:  // the quad face at z=0

      return
        this->compute_key (this->node(0),
                           this->node(3),
                           this->node(2),
                           this->node(1));

    default:
      libmesh_error_msg("Invalid side s = " << s);
    }

  libmesh_error_msg("We'll never get here!");
  return 0;
}

Real libMesh::Elem::length	(	const unsigned int	n1,
		const unsigned int	n2
	)		const `[inherited]`

Returns:: the magnitude of the distance between nodes n1 and n2. Useful for computing the lengths of the sides of elements.

Definition at line 451 of file elem.C.

References libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by libMesh::Hex::quality(), libMesh::InfHex::quality(), and libMesh::Quad::quality().

{
  libmesh_assert_less ( n1, this->n_vertices() );
  libmesh_assert_less ( n2, this->n_vertices() );

  return (this->point(n1) - this->point(n2)).size();
}

unsigned int libMesh::Elem::level ( ) const [inline, inherited]

Returns:: the refinement level of the current element. If the element's parent is NULL then by convention it is at level 0, otherwise it is simply at one level greater than its parent.

Definition at line 1764 of file elem.h.

References libMesh::Elem::dim(), libMesh::Elem::level(), and libMesh::Elem::parent().

{
#ifdef LIBMESH_ENABLE_AMR

  // if I don't have a parent I was
  // created directly from file
  // or by the user, so I am a
  // level-0 element
  if (this->parent() == NULL)
    return 0;

  // if the parent and this element are of different
  // dimensionality we are at the same level as
  // the parent (e.g. we are the 2D side of a
  // 3D element)
  if (this->dim() != this->parent()->dim())
    return this->parent()->level();

  // otherwise we are at a level one
  // higher than our parent
  return (this->parent()->level() + 1);

#else

  // Without AMR all elements are
  // at level 0.
  return 0;

#endif
}

void libMesh::Elem::libmesh_assert_valid_neighbors ( ) const [inherited]

This function checks for consistent neighbor links at this element.

Definition at line 980 of file elem.C.

References libMesh::Elem::dim(), libMesh::libmesh_assert(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::subactive(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::MeshTools::libmesh_assert_valid_neighbors().

{
  for (unsigned int s=0; s<this->n_neighbors(); s++)
    {
      const Elem *neigh = this->neighbor(s);

      // Any element might have a remote neighbor; checking
      // to make sure that's not inaccurate is tough.
      if (neigh == remote_elem)
        continue;

      if (neigh)
        {
          // Only subactive elements have subactive neighbors
          libmesh_assert (this->subactive() || !neigh->subactive());

          const Elem *elem = this;

          // If we're subactive but our neighbor isn't, its
          // return neighbor link will be to our first active
          // ancestor OR to our inactive ancestor of the same
          // level as neigh,
          if (this->subactive() && !neigh->subactive())
            {
              for (elem = this; !elem->active();
                   elem = elem->parent())
                libmesh_assert(elem);
            }
          else
            {
              unsigned int rev = neigh->which_neighbor_am_i(elem);
              libmesh_assert_less (rev, neigh->n_neighbors());

              if (this->subactive() && !neigh->subactive())
                {
                  while (neigh->neighbor(rev) != elem)
                    {
                      libmesh_assert(elem->parent());
                      elem = elem->parent();
                    }
                }
              else
                {
                  Elem *nn = neigh->neighbor(rev);
                  libmesh_assert(nn);

                  for (; elem != nn; elem = elem->parent())
                    libmesh_assert(elem);
                }
            }
        }
      // If we don't have a neighbor and we're not subactive, our
      // ancestors shouldn't have any neighbors in this same
      // direction.
      else if (!this->subactive())
        {
          const Elem *my_parent = this->parent();
          if (my_parent &&
              // A parent with a different dimension isn't really one of
              // our ancestors, it means we're on a boundary mesh and this
              // is an interior mesh element for which we're on a side.
              // Nothing to test for in that case.
              (my_parent->dim() == this->dim()))
            libmesh_assert (!my_parent->neighbor(s));
        }
    }
}

void libMesh::Elem::libmesh_assert_valid_node_pointers ( ) const [inherited]

This function checks for a valid id and for pointers to nodes with valid ids at this element.

Definition at line 968 of file elem.C.

References libMesh::Elem::get_node(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), and libMesh::DofObject::valid_id().

Referenced by libMesh::MeshTools::libmesh_assert_valid_node_pointers().

{
  libmesh_assert(this->valid_id());
  for (unsigned int n=0; n != this->n_nodes(); ++n)
    {
      libmesh_assert(this->get_node(n));
      libmesh_assert(this->get_node(n)->valid_id());
    }
}

unsigned int libMesh::Elem::local_node ( const dof_id_type i ) const [inline, inherited]

Returns:: the local id number of global Node id i, or invalid_uint if Node id i is not local.

Definition at line 1384 of file elem.h.

References libMesh::invalid_uint, libMesh::Elem::n_nodes(), and libMesh::Elem::node().

Referenced by libMesh::MeshTools::find_nodal_neighbors(), and libMesh::SerialMesh::stitching_helper().

{
  for (unsigned int n=0; n != this->n_nodes(); ++n)
    if (this->node(n) == i)
      return n;

  return libMesh::invalid_uint;
}

void libMesh::Elem::make_links_to_me_local ( unsigned int n ) [inherited]

Resets the appropriate neighbor pointers of our nth neighbor (and its descendants, if appropriate) to point to this Elem instead of to the global remote_elem. Used by the library when a formerly remote element is being added to the local processor.

Definition at line 1052 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::is_remote(), libMesh::Elem::JUST_REFINED, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::Elem::set_neighbor(), libMesh::Elem::side(), and libMesh::Elem::subactive().

Referenced by libMesh::Parallel::unpack().

{
  Elem *neigh = this->neighbor(n);

  // Don't bother calling this function unless it's necessary
  libmesh_assert(neigh);
  libmesh_assert(!neigh->is_remote());

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

  // We never have subactive neighbors of non subactive elements
  libmesh_assert(!neigh->subactive() || this->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() == this->level() ||
                 neigh->active());

  // If neigh is at our level, then its family might have
  // remote_elem neighbor links which need to point to us
  // instead, but if not, then we're done.
  if (neigh->level() != this->level())
    return;

  // If neigh is subactive then we're not updating its neighbor links
  // FIXME - this needs to change when we start using subactive
  // elements for more than just the two-phase
  // restriction/prolongation projections.
  if (neigh->subactive())
    return;

  // What side of neigh are we on?  We can't use the usual Elem
  // method because we're in the middle of restoring topology
  const UniquePtr<Elem> my_side = this->side(n);
  unsigned int nn = 0;
  for (; nn != neigh->n_sides(); ++nn)
    {
      const UniquePtr<Elem> neigh_side = neigh->side(nn);
      if (*my_side == *neigh_side)
        break;
    }

  // we 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 (this->active())
    neigh->family_tree_by_side(neigh_family, nn);
  else
#endif
    neigh_family.push_back(neigh);

  // 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]);

      // Ideally, the neighbor link ought to either be correct
      // already or ought to be to remote_elem.
      //
      // However, if we're redistributing a newly created elem,
      // after an AMR step but before find_neighbors has fixed up
      // neighbor links, we might have an out of date neighbor
      // link to elem's parent instead.
#ifdef LIBMESH_ENABLE_AMR
      libmesh_assert((neigh_family_member->neighbor(nn) == this) ||
                     (neigh_family_member->neighbor(nn) == remote_elem)
                     || ((this->refinement_flag() == JUST_REFINED) &&
                         (this->parent() != NULL) &&
                         (neigh_family_member->neighbor(nn) == this->parent())));
#else
      libmesh_assert((neigh_family_member->neighbor(nn) == this) ||
                     (neigh_family_member->neighbor(nn) == remote_elem));
#endif

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

void libMesh::Elem::make_links_to_me_remote ( ) [inherited]

Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to the global remote_elem instead of this. Used by the library before a remote element is deleted on the local processor.

Definition at line 1136 of file elem.C.

References libMesh::Elem::child(), libMesh::Elem::dim(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::has_children(), libMesh::Elem::has_neighbor(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::set_child(), libMesh::Elem::set_neighbor(), libMesh::Elem::subactive(), libMesh::Elem::which_child_am_i(), and libMesh::Elem::which_neighbor_am_i().

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

{
  libmesh_assert_not_equal_to (this, remote_elem);

  // We need to have handled any children first
#if defined(LIBMESH_ENABLE_AMR) && defined(DEBUG)
  if (this->has_children())
    for (unsigned int c = 0; c != this->n_children(); ++c)
      {
        Elem *current_child = this->child(c);
        libmesh_assert_equal_to (current_child, remote_elem);
      }
#endif

  // Remotify any neighbor links to non-subactive elements
  if (!this->subactive())
    {
      for (unsigned int s = 0; s != this->n_sides(); ++s)
        {
          Elem *neigh = this->neighbor(s);
          if (neigh && neigh != remote_elem && !neigh->subactive())
            {
              // My neighbor should never be more refined than me; my real
              // neighbor would have been its parent in that case.
              libmesh_assert_greater_equal (this->level(), neigh->level());

              if (this->level() == neigh->level() &&
                  neigh->has_neighbor(this))
                {
#ifdef LIBMESH_ENABLE_AMR
                  // My neighbor may have descendants which also consider me a
                  // neighbor
                  std::vector<const Elem*> family;
                  neigh->family_tree_by_neighbor (family, this);

                  // FIXME - There's a lot of ugly const_casts here; we
                  // may want to make remote_elem non-const and create
                  // non-const versions of the family_tree methods
                  for (unsigned int i=0; i != family.size(); ++i)
                    {
                      Elem *n = const_cast<Elem*>(family[i]);
                      libmesh_assert (n);
                      if (n == remote_elem)
                        continue;
                      unsigned int my_s = n->which_neighbor_am_i(this);
                      libmesh_assert_less (my_s, n->n_neighbors());
                      libmesh_assert_equal_to (n->neighbor(my_s), this);
                      n->set_neighbor(my_s, const_cast<RemoteElem*>(remote_elem));
                    }
#else
                  unsigned int my_s = neigh->which_neighbor_am_i(this);
                  libmesh_assert_less (my_s, neigh->n_neighbors());
                  libmesh_assert_equal_to (neigh->neighbor(my_s), this);
                  neigh->set_neighbor(my_s, const_cast<RemoteElem*>(remote_elem));
#endif
                }
#ifdef LIBMESH_ENABLE_AMR
              // Even if my neighbor doesn't link back to me, it might
              // have subactive descendants which do
              else if (neigh->has_children())
                {
                  // If my neighbor at the same level doesn't have me as a
                  // neighbor, I must be subactive
                  libmesh_assert(this->level() > neigh->level() ||
                                 this->subactive());

                  // My neighbor must have some ancestor of mine as a
                  // neighbor
                  Elem *my_ancestor = this->parent();
                  libmesh_assert(my_ancestor);
                  while (!neigh->has_neighbor(my_ancestor))
                    {
                      my_ancestor = my_ancestor->parent();
                      libmesh_assert(my_ancestor);
                    }

                  // My neighbor may have descendants which consider me a
                  // neighbor
                  std::vector<const Elem*> family;
                  neigh->family_tree_by_subneighbor (family, my_ancestor, this);

                  // FIXME - There's a lot of ugly const_casts here; we
                  // may want to make remote_elem non-const and create
                  // non-const versions of the family_tree methods
                  for (unsigned int i=0; i != family.size(); ++i)
                    {
                      Elem *n = const_cast<Elem*>(family[i]);
                      libmesh_assert (n);
                      if (n == remote_elem)
                        continue;
                      unsigned int my_s = n->which_neighbor_am_i(this);
                      libmesh_assert_less (my_s, n->n_neighbors());
                      libmesh_assert_equal_to (n->neighbor(my_s), this);
                      n->set_neighbor(my_s, const_cast<RemoteElem*>(remote_elem));
                    }
                }
#endif
            }
        }
    }

#ifdef LIBMESH_ENABLE_AMR
  // Remotify parent's child link
  Elem *my_parent = this->parent();
  if (my_parent &&
      // As long as it's not already remote
      my_parent != remote_elem &&
      // And it's a real parent, not an interior parent
      this->dim() == my_parent->dim())
    {
      unsigned int me = my_parent->which_child_am_i(this);
      libmesh_assert_equal_to (my_parent->child(me), this);
      my_parent->set_child(me, const_cast<RemoteElem*>(remote_elem));
    }
#endif
}

unsigned int libMesh::Elem::max_descendant_p_level ( ) const [inline, inherited]

Returns the maximum value of the p refinement levels of an ancestor element's descendants

Definition at line 1882 of file elem.h.

References libMesh::Elem::_p_level, libMesh::Elem::active(), libMesh::Elem::child(), libMesh::libmesh_assert(), std::max(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::n_children(), libMesh::Elem::p_level(), and libMesh::Elem::subactive().

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), and libMesh::Elem::max_descendant_p_level().

{
  // This is undefined for subactive elements,
  // which have no active descendants
  libmesh_assert (!this->subactive());
  if (this->active())
    return this->p_level();

  unsigned int max_p_level = _p_level;
  for (unsigned int c=0; c != this->n_children(); c++)
    max_p_level = std::max(max_p_level,
                           this->child(c)->max_descendant_p_level());
  return max_p_level;
}

unsigned int libMesh::Elem::min_new_p_level_by_neighbor	(	const Elem *	neighbor,
		unsigned int	current_min
	)		const `[inherited]`

Returns the minimum new p refinement level (i.e. after refinement and coarsening is done) of elements which are descended from this and which share a side with the active neighbor

Definition at line 1680 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::COARSEN, libMesh::Elem::has_neighbor(), libMesh::libmesh_assert(), std::min(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::n_children(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::REFINE, libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::MeshRefinement::eliminate_unrefined_patches(), and libMesh::Elem::min_new_p_level_by_neighbor().

{
  libmesh_assert(!this->subactive());
  libmesh_assert(neighbor_in->active());

  // If we're an active element this is simple
  if (this->active())
    {
      unsigned int new_p_level = this->p_level();
      if (this->p_refinement_flag() == Elem::REFINE)
        new_p_level += 1;
      if (this->p_refinement_flag() == Elem::COARSEN)
        {
          libmesh_assert_greater (new_p_level, 0);
          new_p_level -= 1;
        }
      return std::min(current_min, new_p_level);
    }

  libmesh_assert(has_neighbor(neighbor_in));

  unsigned int min_p_level = current_min;

  for (unsigned int c=0; c<this->n_children(); c++)
    {
      const Elem* const current_child = this->child(c);
      if (current_child && current_child != remote_elem)
        if (current_child->has_neighbor(neighbor_in))
          min_p_level =
            current_child->min_new_p_level_by_neighbor(neighbor_in,
                                                       min_p_level);
    }

  return min_p_level;
}

unsigned int libMesh::Elem::min_p_level_by_neighbor	(	const Elem *	neighbor,
		unsigned int	current_min
	)		const `[inherited]`

Returns the minimum p refinement level of elements which are descended from this and which share a side with the active neighbor

Definition at line 1647 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::has_neighbor(), libMesh::libmesh_assert(), std::min(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::n_children(), libMesh::Elem::p_level(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), and libMesh::Elem::min_p_level_by_neighbor().

{
  libmesh_assert(!this->subactive());
  libmesh_assert(neighbor_in->active());

  // If we're an active element this is simple
  if (this->active())
    return std::min(current_min, this->p_level());

  libmesh_assert(has_neighbor(neighbor_in));

  // The p_level() of an ancestor element is already the minimum
  // p_level() of its children - so if that's high enough, we don't
  // need to examine any children.
  if (current_min <= this->p_level())
    return current_min;

  unsigned int min_p_level = current_min;

  for (unsigned int c=0; c<this->n_children(); c++)
    {
      const Elem* const current_child = this->child(c);
      if (current_child != remote_elem && current_child->has_neighbor(neighbor_in))
        min_p_level =
          current_child->min_p_level_by_neighbor(neighbor_in,
                                                 min_p_level);
    }

  return min_p_level;
}

unsigned int libMesh::Pyramid::n_children ( ) const [inline, virtual, inherited]

Returns:: 10

Implements libMesh::Elem.

Definition at line 75 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::is_child_on_side().

{ return 10; }

unsigned int libMesh::DofObject::n_comp	(	const unsigned int	s,
		const unsigned int	var
	)		const `[inline, inherited]`

Returns:: the number of components for variable var of system s associated with this DofObject. For example, the HIERARCHIC shape functions may have multiple DoFs associated with one node. Another example is the MONOMIALs, where only the elements hold the DoFs. For the different spatial directions, and orders, see FE.

Definition at line 767 of file dof_object.h.

References libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), and libMesh::DofObject::var_to_vg().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), libMesh::DofObject::n_dofs(), libMesh::DofMap::old_dof_indices(), libMesh::DofObject::operator=(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), and libMesh::System::zero_variable().

{
  libmesh_assert_less (s,   this->n_systems());
  libmesh_assert_less (var, this->n_vars(s));

  return this->n_comp_group(s,this->var_to_vg(s,var));
}

unsigned int libMesh::DofObject::n_comp_group	(	const unsigned int	s,
		const unsigned int	vg
	)		const `[inline, inherited]`

Returns:: the number of components for VariableGroup vg of system s associated with this DofObject. For example, the HIERARCHIC shape functions may have multiple DoFs associated with one node. Another example is the MONOMIALs, where only the elements hold the DoFs. For the different spatial directions, and orders, see FE.

Definition at line 780 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::ncv_magic, and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::dof_number(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp(), libMesh::DofMap::reinit(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));

  const unsigned int
    start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());

  return (_idx_buf[start_idx_sys + 2*vg] % ncv_magic);
}

unsigned int libMesh::DofObject::n_dofs	(	const unsigned int	s,
		const unsigned int	var = `libMesh::invalid_uint`
	)		const `[inline, inherited]`

Returns:: the number of degrees of freedom associated with system s for this object. Optionally only counts degrees of freedom for variable number var

Definition at line 597 of file dof_object.h.

References libMesh::invalid_uint, libMesh::DofObject::n_comp(), libMesh::DofObject::n_systems(), and libMesh::DofObject::n_vars().

Referenced by libMesh::EquationSystems::build_solution_vector().

{
  libmesh_assert_less (s, this->n_systems());

  unsigned int num = 0;

  // Count all variables
  if (var == libMesh::invalid_uint)
    for (unsigned int v=0; v<this->n_vars(s); v++)
      num += this->n_comp(s,v);

  // Only count specified variable
  else
    num = this->n_comp(s,var);

  return num;
}

unsigned int libMesh::Pyramid::n_edges ( ) const [inline, virtual, inherited]

Returns:: 8. All pyramids have 8 edges.

Implements libMesh::Elem.

Definition at line 65 of file cell_pyramid.h.

Referenced by build_edge(), libMesh::Pyramid13::build_edge(), libMesh::Pyramid14::build_edge(), libMesh::Pyramid::is_edge_on_side(), is_node_on_edge(), libMesh::Pyramid13::is_node_on_edge(), and libMesh::Pyramid14::is_node_on_edge().

{ return 8; }

unsigned int libMesh::Pyramid::n_faces ( ) const [inline, virtual, inherited]

Returns:: 5. All pyramids have 5 faces.

Implements libMesh::Elem.

Definition at line 70 of file cell_pyramid.h.

{ return 5; }

virtual unsigned int libMesh::Elem::n_neighbors ( ) const [inline, virtual, inherited]

Returns:: the number of neighbors the element that has been derived from this class has. By default only face (or edge in 2D) neighbors are stored, so this method returns n_sides(), however it may be overloaded in a derived class

Definition at line 444 of file elem.h.

References libMesh::Elem::n_sides().

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::Elem::_last_side(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::TetGenMeshInterface::check_hull_integrity(), libMesh::Elem::child_neighbor(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Tri3Subdivision::get_ordered_valence(), libMesh::Elem::has_neighbor(), libMesh::Elem::has_topological_neighbor(), libMesh::LaplaceMeshSmoother::init(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::neighbor(), libMesh::Elem::nullify_neighbors(), libMesh::Parallel::pack(), libMesh::Parallel::packable_size(), libMesh::Elem::set_neighbor(), libMesh::MeshTools::Modification::smooth(), libMesh::SerialMesh::stitching_helper(), libMesh::MeshRefinement::test_level_one(), libMesh::Elem::topological_neighbor(), libMesh::Parallel::unpack(), and libMesh::Elem::which_neighbor_am_i().

  { return this->n_sides(); }

unsigned int libMesh::Pyramid::n_nodes ( ) const [inline, virtual, inherited]

Returns:: 5. All pyramid-derivatives are guaranteed to have at least 5 nodes.

Implements libMesh::Elem.

Reimplemented in libMesh::Pyramid14, and libMesh::Pyramid13.

Definition at line 50 of file cell_pyramid.h.

{ return 5; }

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

unsigned int libMesh::Elem::n_second_order_adjacent_vertices ( const unsigned int n ) const [virtual, inherited]

Returns:: the number of adjacent vertices, that uniquely define the location of the $n^{th}$ second-order node. For linear elements ( default_order()==FIRST ), this returns 0. This method is useful when converting linear elements to quadratic elements. Note that n has to be greater or equal this->n_vertices().

Reimplemented in libMesh::InfHex18, libMesh::Prism18, libMesh::Hex27, libMesh::Pyramid14, libMesh::InfHex16, libMesh::Prism15, libMesh::Pyramid13, libMesh::Hex20, libMesh::Tet10, libMesh::InfPrism12, libMesh::Quad8, libMesh::Tri6, libMesh::Quad9, libMesh::InfQuad6, libMesh::Edge3, and libMesh::Edge4.

Definition at line 1965 of file elem.C.

Referenced by libMesh::LaplaceMeshSmoother::smooth(), and libMesh::MeshTools::Modification::smooth().

{
  // for linear elements, always return 0
  return 0;
}

unsigned int libMesh::Pyramid::n_sides ( ) const [inline, virtual, inherited]

Returns:: 5

Implements libMesh::Elem.

Definition at line 55 of file cell_pyramid.h.

Referenced by build_side(), libMesh::Pyramid13::build_side(), libMesh::Pyramid14::build_side(), libMesh::Pyramid::is_child_on_side(), libMesh::Pyramid::is_edge_on_side(), is_node_on_side(), libMesh::Pyramid13::is_node_on_side(), libMesh::Pyramid14::is_node_on_side(), libMesh::Pyramid::key(), and libMesh::Pyramid::side().

{ return 5; }

unsigned int libMesh::Pyramid5::n_sub_elem ( ) const [inline, virtual]

Returns:: 1

Implements libMesh::Elem.

Definition at line 71 of file cell_pyramid5.h.

Referenced by connectivity().

{ return 1; }

unsigned int libMesh::DofObject::n_systems ( ) const [inline, inherited]

Returns:: the number of systems associated with this DofObject

Definition at line 713 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

{
  return _idx_buf.empty() ?
    0 : cast_int<unsigned int>(_idx_buf[0]);
}

unsigned int libMesh::DofObject::n_var_groups ( const unsigned int s ) const [inline, inherited]

Returns:: the number of VariableGroup variable groups associated with system s for this DofObject

Definition at line 722 of file dof_object.h.

References libMesh::DofObject::end_idx(), libMesh::DofObject::n_systems(), and libMesh::DofObject::start_idx().

{
  libmesh_assert_less (s, this->n_systems());

  return (this->end_idx(s) - this->start_idx(s)) / 2;
}

unsigned int libMesh::DofObject::n_vars	(	const unsigned int	s,
		const unsigned int	vg
	)		const `[inline, inherited]`

Returns:: the number of Variable variables associated with VariableGroup vg in system s for this DofObject

Definition at line 732 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::ncv_magic_exp, and libMesh::DofObject::start_idx().

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));

  const unsigned int start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());

  return (cast_int<unsigned int>
          (_idx_buf[start_idx_sys + 2*vg]) >> ncv_magic_exp);
}

unsigned int libMesh::DofObject::n_vars ( const unsigned int s ) const [inline, inherited]

Returns:: the number of Variable variables associated with system s for this DofObject

Definition at line 749 of file dof_object.h.

References libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::n_vars().

{
  libmesh_assert_less (s, this->n_systems());

  const unsigned int nvg = this->n_var_groups(s);

  unsigned int val=0;

  for (unsigned int vg=0; vg<nvg; vg++)
    val += this->n_vars(s,vg);

  return val;
}

unsigned int libMesh::Pyramid::n_vertices ( ) const [inline, virtual, inherited]

Returns:: 5. All pyramids have 5 vertices.

Implements libMesh::Elem.

Definition at line 60 of file cell_pyramid.h.

Referenced by libMesh::Pyramid13::second_order_adjacent_vertex(), and libMesh::Pyramid14::second_order_adjacent_vertex().

{ return 5; }

Elem * libMesh::Elem::neighbor ( const unsigned int i ) const [inline, inherited]

Returns:: a pointer to the $i^{th}$ neighbor of this element. If MeshBase::find_neighbors() has not been called this simply returns NULL. If MeshBase::find_neighbors() has been called and this returns NULL then the side is on a boundary of the domain.

Definition at line 1453 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

{
  libmesh_assert_less (i, this->n_neighbors());

  return _elemlinks[i+1];
}

dof_id_type libMesh::Elem::node ( const unsigned int i ) const [inline, inherited]

Returns:: the global id number of local Node i.

Reimplemented in libMesh::RemoteElem.

Definition at line 1372 of file elem.h.

References libMesh::Elem::_nodes, libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);

  return _nodes[i]->id();
}

void libMesh::Elem::nullify_neighbors ( ) [inherited]

Replaces this element with NULL for all of its neighbors. This is useful when deleting an element.

Definition at line 1939 of file elem.C.

References libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor(), libMesh::remote_elem, libMesh::Elem::set_neighbor(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::MeshRefinement::_coarsen_elements().

{
  // Tell any of my neighbors about my death...
  // Looks strange, huh?
  for (unsigned int n=0; n<this->n_neighbors(); n++)
    {
      Elem* current_neighbor = this->neighbor(n);
      if (current_neighbor && current_neighbor != remote_elem)
        {
          // Note:  it is possible that I see the neighbor
          // (which is coarser than me)
          // but they don't see me, so avoid that case.
          if (current_neighbor->level() == this->level())
            {
              const unsigned int w_n_a_i = current_neighbor->which_neighbor_am_i(this);
              libmesh_assert_less (w_n_a_i, current_neighbor->n_neighbors());
              current_neighbor->set_neighbor(w_n_a_i, NULL);
              this->set_neighbor(n, NULL);
            }
        }
    }
}

bool libMesh::Elem::on_boundary ( ) const [inline, inherited]

Returns:: true if this element has a side coincident with a boundary (indicated by a NULL neighbor), false otherwise.

Definition at line 1511 of file elem.h.

References libMesh::Elem::has_neighbor().

{
  // By convention, the element is on the boundary
  // if it has a NULL neighbor.
  return this->has_neighbor(NULL);
}

bool libMesh::Elem::operator== ( const Elem & rhs ) const [inherited]

Returns:: true if two elements are identical, false otherwise. This is true if the elements are connected to identical global nodes, regardless of how those nodes might be numbered local to the elements.

Definition at line 462 of file elem.C.

References libMesh::Elem::n_nodes(), and libMesh::Elem::node().

{

  // Cast rhs to an Elem*
  //    const Elem* rhs_elem = dynamic_cast<const Elem*>(&rhs);
  const Elem* rhs_elem = &rhs;

  // If we cannot cast to an Elem*, rhs must be a Node
  //    if(rhs_elem == static_cast<const Elem*>(NULL))
  //        return false;

  //   libmesh_assert (n_nodes());
  //   libmesh_assert (rhs.n_nodes());

  //   // Elements can only be equal if they
  //   // contain the same number of nodes.
  //   if (this->n_nodes() == rhs.n_nodes())
  //     {
  //       // Create a set that contains our global
  //       // node numbers and those of our neighbor.
  //       // If the set is the same size as the number
  //       // of nodes in both elements then they must
  //       // be connected to the same nodes.
  //       std::set<unsigned int> nodes_set;

  //       for (unsigned int n=0; n<this->n_nodes(); n++)
  //         {
  //           nodes_set.insert(this->node(n));
  //           nodes_set.insert(rhs.node(n));
  //         }

  //       // If this passes the elements are connected
  //       // to the same global nodes
  //       if (nodes_set.size() == this->n_nodes())
  //         return true;
  //     }

  //   // If we get here it is because the elements either
  //   // do not have the same number of nodes or they are
  //   // connected to different nodes.  Either way they
  //   // are not the same element
  //   return false;

  // Useful typedefs
  typedef std::vector<dof_id_type>::iterator iterator;


  // Elements can only be equal if they
  // contain the same number of nodes.
  // However, we will only test the vertices,
  // which is sufficient & cheaper
  if (this->n_nodes() == rhs_elem->n_nodes())
    {
      // The number of nodes in the element
      const unsigned int nn = this->n_nodes();

      // Create a vector that contains our global
      // node numbers and those of our neighbor.
      // If the sorted, unique vector is the same size
      // as the number of nodes in both elements then
      // they must be connected to the same nodes.
      //
      // The vector will be no larger than 2*n_nodes(),
      // so we might as well reserve the space.
      std::vector<dof_id_type> common_nodes;
      common_nodes.reserve (2*nn);

      // Add the global indices of the nodes
      for (unsigned int n=0; n<nn; n++)
        {
          common_nodes.push_back (this->node(n));
          common_nodes.push_back (rhs_elem->node(n));
        }

      // Sort the vector and find out how long
      // the sorted vector is.
      std::sort (common_nodes.begin(), common_nodes.end());

      iterator new_end = std::unique (common_nodes.begin(),
                                      common_nodes.end());

      const int new_size = cast_int<int>
        (std::distance (common_nodes.begin(), new_end));

      // If this passes the elements are connected
      // to the same global vertex nodes
      if (new_size == static_cast<int>(nn))
        return true;
    }

  // If we get here it is because the elements either
  // do not have the same number of nodes or they are
  // connected to different nodes.  Either way they
  // are not the same element
  return false;
}

unsigned int libMesh::Elem::opposite_node	(	const unsigned int	n,
		const unsigned int	s
	)		const `[virtual, inherited]`

Reimplemented in libMesh::Edge, libMesh::Quad, and libMesh::Hex.

Definition at line 2214 of file elem.C.

{
  // If the subclass didn't rederive this, using it is an error
  libmesh_not_implemented();
}

unsigned int libMesh::Elem::opposite_side ( const unsigned int s ) const [virtual, inherited]

Reimplemented in libMesh::Edge, libMesh::Quad, and libMesh::Hex.

Definition at line 2206 of file elem.C.

{
  // If the subclass didn't rederive this, using it is an error
  libmesh_not_implemented();
}

virtual Point libMesh::Elem::origin ( ) const [inline, virtual, inherited]

Returns:: the origin for an infinite element. Currently, all infinite elements used in a mesh share the same origin. Overload this in infinite element classes. By default, issues an error, because returning the all zero point would very likely lead to unexpected behavior.

Reimplemented in libMesh::InfQuad, libMesh::InfEdge2, and libMesh::InfCell.

Definition at line 1134 of file elem.h.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), and libMesh::InfFE< Dim, T_radial, T_map >::map().

{ libmesh_not_implemented(); return Point(); }

unsigned int libMesh::Elem::p_level ( ) const [inline, inherited]

Returns the value of the p refinement level of an active element, or the minimum value of the p refinement levels of an ancestor element's descendants

Definition at line 1798 of file elem.h.

References libMesh::Elem::_p_level.

{
#ifdef LIBMESH_ENABLE_AMR
  return _p_level;
#else
  return 0;
#endif
}

Elem::RefinementState libMesh::Elem::p_refinement_flag ( ) const [inline, inherited]

Returns the value of the p refinement flag for the element.

Definition at line 1866 of file elem.h.

References libMesh::Elem::_pflag.

{
  return static_cast<RefinementState>(_pflag);
}

void libMesh::DofObject::pack_indexing ( std::back_insert_iterator< std::vector< largest_id_type > > target ) const [inherited]

A method for creating packed data from our index buffer - basically a copy with prepended size with our current implementation.

Definition at line 525 of file dof_object.C.

Referenced by libMesh::Parallel::pack().

{
#ifdef LIBMESH_ENABLE_AMR
  // We might need to pack old_dof_object too
  *target++ = (old_dof_object == NULL) ? 0 : 1;
#endif

  *target++ = _idx_buf.size();
  std::copy(_idx_buf.begin(), _idx_buf.end(), target);

#ifdef LIBMESH_ENABLE_AMR
  if (old_dof_object)
    old_dof_object->pack_indexing(target);
#endif
}

unsigned int libMesh::DofObject::packed_indexing_size ( ) const [inherited]

If we pack our indices into an buffer for communications, how many ints do we need?

Definition at line 450 of file dof_object.C.

References libMesh::DofObject::_idx_buf, and libMesh::DofObject::old_dof_object.

Referenced by libMesh::Parallel::pack(), libMesh::Parallel::packable_size(), libMesh::Node::packed_size(), and libMesh::Parallel::unpack().

{
  return
    cast_int<unsigned int> (
#ifdef LIBMESH_ENABLE_AMR
                            ((old_dof_object == NULL) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
#else
                            1 +
#endif
                            _idx_buf.size());
}

const Elem * libMesh::Elem::parent ( ) const [inline, inherited]

Returns:: a const pointer to the element's parent. Returns NULL if the element was not created via refinement, i.e. was read from file.

Definition at line 1683 of file elem.h.

References libMesh::Elem::_elemlinks.

{
  return _elemlinks[0];
}

Elem * libMesh::Elem::parent ( ) [inline, inherited]

Returns:: a pointer to the element's parent. Returns NULL if the element was not created via refinement, i.e. was read from file.

Definition at line 1691 of file elem.h.

References libMesh::Elem::_elemlinks.

{
  return _elemlinks[0];
}

const Point & libMesh::Elem::point ( const unsigned int i ) const [inline, inherited]

Returns:: the Point associated with local Node i.

Reimplemented in libMesh::RemoteElem.

Definition at line 1350 of file elem.h.

References libMesh::Elem::_nodes, libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);

  return *_nodes[i];
}

Point & libMesh::Elem::point ( const unsigned int i ) [inline, inherited]

Returns:: the Point associated with local Node i as a writeable reference.

Reimplemented in libMesh::RemoteElem.

Definition at line 1362 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());

  return *_nodes[i];
}

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

{
  if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

{
  if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}

void libMesh::Elem::print_info ( std::ostream & os = libMesh::out ) const [inherited]

Prints relevant information about the element.

Definition at line 1862 of file elem.C.

References libMesh::Elem::get_info().

Referenced by libMesh::FE< Dim, T >::inverse_map(), and libMesh::operator<<().

{
  os << this->get_info()
     << std::endl;
}

processor_id_type libMesh::DofObject::processor_id ( ) const [inline, inherited]

Returns:: the processor that this DofObject belongs to.

When partitioning and DoF numbering have been performed by libMesh, every current DoF on this DofObject will belong to its processor.

Definition at line 681 of file dof_object.h.

References libMesh::DofObject::_processor_id.

{
  return _processor_id;
}

processor_id_type & libMesh::DofObject::processor_id ( ) [inline, inherited]

Returns:: the processor that this DofObject belongs to as a writeable reference.

Definition at line 689 of file dof_object.h.

References libMesh::DofObject::_processor_id.

{
  return _processor_id;
}

void libMesh::DofObject::processor_id ( const processor_id_type pid ) [inline, inherited]

Sets the processor_id for this DofObject.

Definition at line 697 of file dof_object.h.

References libMesh::DofObject::processor_id().

{
  this->processor_id() = pid;
}

virtual std::pair<Real,Real> libMesh::Elem::qual_bounds ( const ElemQuality ) const [inline, virtual, inherited]

Returns the suggested quality bounds for the hex based on quality measure q. These are the values suggested by the CUBIT User's Manual. Since this function can have no possible meaning for an abstract Elem, it is an error.

Reimplemented in libMesh::InfQuad, libMesh::Quad, libMesh::InfHex, libMesh::Tri, libMesh::Hex, and libMesh::Tet.

Definition at line 621 of file elem.h.

  { libmesh_not_implemented(); return std::make_pair(0.,0.); }

Real libMesh::Elem::quality ( const ElemQuality q ) const [virtual, inherited]

Based on the quality metric q specified by the user, returns a quantitative assessment of element quality.

I don't know what to do for this metric.

Reimplemented in libMesh::InfQuad, libMesh::Quad, libMesh::InfHex, libMesh::Tri, libMesh::Hex, and libMesh::Tet.

Definition at line 1298 of file elem.C.

References libMesh::Utility::enum_to_string(), and libMesh::err.

{
  switch (q)
    {
    default:
      {
        libmesh_do_once( libmesh_here();

                         libMesh::err << "ERROR:  unknown quality metric: "
                         << Utility::enum_to_string(q)
                         << std::endl
                         << "Cowardly returning 1."
                         << std::endl; );

        return 1.;
      }
    }

  libmesh_error_msg("We'll never get here!");
  return 0.;
}

const Elem * libMesh::Elem::reference_elem ( ) const [inherited]

Returns:: a pointer to the "reference element" associated with this element. The reference element is the image of this element in reference parametric space. Importantly, it is *not* an actual element in the mesh, but rather a Singleton-type object, so for example all Quad4 elements share the same reference_elem().

Definition at line 398 of file elem.C.

References libMesh::ReferenceElem::get(), and libMesh::Elem::type().

Referenced by libMesh::QComposite< QSubCell >::init().

{
  return &(ReferenceElem::get(this->type()));
}

void libMesh::Elem::refine ( MeshRefinement & mesh_refinement ) [virtual, inherited]

Refine the element.

The following functions only apply when AMR is enabled and thus are not present otherwise.

Definition at line 41 of file elem_refinement.C.

References libMesh::Elem::_children, libMesh::Elem::active(), libMesh::MeshRefinement::add_elem(), libMesh::MeshRefinement::add_point(), libMesh::Elem::ancestor(), libMesh::Elem::build(), libMesh::Elem::child(), libMesh::Elem::embedding_matrix(), libMesh::Elem::get_node(), libMesh::Elem::hmin(), libMesh::Elem::INACTIVE, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_nodes(), libMesh::DofObject::n_systems(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::Elem::point(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::Elem::REFINE, libMesh::Elem::refinement_flag(), libMesh::DofObject::set_n_systems(), libMesh::Elem::set_node(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_refinement_flag(), libMesh::Elem::subactive(), libMesh::TOLERANCE, and libMesh::Elem::type().

{
  libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
  libmesh_assert (this->active());

  // Create my children if necessary
  if (!_children)
    {
      _children = new Elem*[this->n_children()];

      unsigned int parent_p_level = this->p_level();
      for (unsigned int c=0; c<this->n_children(); c++)
        {
          _children[c] = Elem::build(this->type(), this).release();
          _children[c]->set_refinement_flag(Elem::JUST_REFINED);
          _children[c]->set_p_level(parent_p_level);
          _children[c]->set_p_refinement_flag(this->p_refinement_flag());
        }

      // Compute new nodal locations
      // and asssign nodes to children
      // Make these static.  It is unlikely the
      // sizes will change from call to call, so having these
      // static should save on reallocations
      std::vector<std::vector<Point> >        p    (this->n_children());
      std::vector<std::vector<Node*> >        nodes(this->n_children());


      // compute new nodal locations
      for (unsigned int c=0; c<this->n_children(); c++)
        {
          Elem *current_child = this->child(c);
          p[c].resize    (current_child->n_nodes());
          nodes[c].resize(current_child->n_nodes());

          for (unsigned int nc=0; nc<current_child->n_nodes(); nc++)
            {
              // zero entries
              p[c][nc].zero();
              nodes[c][nc] = NULL;

              for (unsigned int n=0; n<this->n_nodes(); n++)
                {
                  // The value from the embedding matrix
                  const float em_val = this->embedding_matrix(c,nc,n);

                  if (em_val != 0.)
                    {
                      p[c][nc].add_scaled (this->point(n), em_val);

                      // We may have found the node, in which case we
                      // won't need to look it up later.
                      if (em_val == 1.)
                        nodes[c][nc] = this->get_node(n);
                    }
                }
            }

          // assign nodes to children & add them to the mesh
          const Real pointtol = this->hmin() * TOLERANCE;
          for (unsigned int nc=0; nc<current_child->n_nodes(); nc++)
            {
              if (nodes[c][nc] != NULL)
                {
                  current_child->set_node(nc) = nodes[c][nc];
                }
              else
                {
                  current_child->set_node(nc) =
                    mesh_refinement.add_point(p[c][nc],
                                              current_child->processor_id(),
                                              pointtol);
                  current_child->get_node(nc)->set_n_systems
                    (this->n_systems());
                }
            }

          mesh_refinement.add_elem (current_child);
          current_child->set_n_systems(this->n_systems());
        }
    }
  else
    {
      unsigned int parent_p_level = this->p_level();
      for (unsigned int c=0; c<this->n_children(); c++)
        {
          Elem *current_child = this->child(c);
          libmesh_assert(current_child->subactive());
          current_child->set_refinement_flag(Elem::JUST_REFINED);
          current_child->set_p_level(parent_p_level);
          current_child->set_p_refinement_flag(this->p_refinement_flag());
        }
    }

  // Un-set my refinement flag now
  this->set_refinement_flag(Elem::INACTIVE);
  this->set_p_refinement_flag(Elem::INACTIVE);

  for (unsigned int c=0; c<this->n_children(); c++)
    {
      libmesh_assert_equal_to (this->child(c)->parent(), this);
      libmesh_assert(this->child(c)->active());
    }
  libmesh_assert (this->ancestor());
}

Elem::RefinementState libMesh::Elem::refinement_flag ( ) const [inline, inherited]

Returns the value of the refinement flag for the element.

Definition at line 1850 of file elem.h.

References libMesh::Elem::_rflag.

{
  return static_cast<RefinementState>(_rflag);
}

void libMesh::Elem::replace_child	(	Elem *	elem,
		unsigned int	c
	)		`[inherited]`

Replaces the child pointer at the specified index in the array of children of this element.

Definition at line 1390 of file elem.C.

References libMesh::Elem::child(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), and libMesh::Elem::set_child().

Referenced by libMesh::UnstructuredMesh::all_first_order().

{
  libmesh_assert(this->has_children());

  libmesh_assert(this->child(c));

  this->set_child(c, elem);
}

unsigned short int libMesh::Elem::second_order_adjacent_vertex	(	const unsigned int	n,
		const unsigned int	v
	)		const `[virtual, inherited]`

Returns:: the element-local number of the $v^{th}$ vertex that defines the $n^{th}$ second-order node. Note that the return value is always less this->n_vertices(), while n has to be greater or equal this->n_vertices(). For linear elements this returns 0.

Reimplemented in libMesh::InfHex18, libMesh::Prism18, libMesh::Hex27, libMesh::InfHex16, libMesh::Pyramid14, libMesh::Prism15, libMesh::Hex20, libMesh::Pyramid13, libMesh::Tet10, libMesh::InfPrism12, libMesh::Quad8, libMesh::Tri6, libMesh::Quad9, libMesh::InfQuad6, libMesh::Edge3, and libMesh::Edge4.

Definition at line 1973 of file elem.C.

Referenced by libMesh::LaplaceMeshSmoother::smooth(), and libMesh::MeshTools::Modification::smooth().

{
  // for linear elements, always return 0
  return 0;
}

std::pair< unsigned short int, unsigned short int > libMesh::Elem::second_order_child_vertex ( const unsigned int n ) const [virtual, inherited]

Returns:: the child number c and element-local index v of the $n^{th}$ second-order node on the parent element. Note that the return values are always less this->n_children() and this->child(c)->n_vertices(), while n has to be greater or equal to * this->n_vertices(). For linear elements this returns 0,0. On refined second order elements, the return value will satisfy this->get_node(n)==this->child(c)->get_node(v)

Reimplemented in libMesh::InfHex18, libMesh::Prism18, libMesh::Hex27, libMesh::InfHex16, libMesh::Prism15, libMesh::Hex20, libMesh::Tet10, libMesh::InfPrism12, libMesh::Quad8, libMesh::Tri6, libMesh::Quad9, libMesh::InfQuad6, and libMesh::Edge3.

Definition at line 1983 of file elem.C.

{
  // for linear elements, always return 0
  return std::pair<unsigned short int, unsigned short int>(0,0);
}

ElemType libMesh::Elem::second_order_equivalent_type	(	const ElemType	et,
		const bool	full_ordered = `true`
	)		`[static, inherited]`

Returns:: the element type of the associated second-order element, e.g. when this is a TET4, then TET10 is returned. Returns INVALID_ELEM for second order or other elements that should not or cannot be converted into higher order equivalents.

For some elements, there exist two second-order equivalents, e.g. for Quad4 there is Quad8 and Quad9. When the optional full_ordered is true, then QUAD9 is returned. When full_ordered is false, then QUAD8 is returned.

Definition at line 2045 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::INVALID_ELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.

Referenced by libMesh::UnstructuredMesh::all_second_order().

{
  /* for second-order elements, always return \p INVALID_ELEM
   * since second-order elements should not be converted
   * into something else.  Only linear elements should
   * return something sensible here
   */
  switch (et)
    {
    case EDGE2:
      {
        // full_ordered not relevant
        return EDGE3;
      }

    case TRI3:
      {
        // full_ordered not relevant
        return TRI6;
      }

    case QUAD4:
      {
        if (full_ordered)
          return QUAD9;
        else
          return QUAD8;
      }

    case TET4:
      {
        // full_ordered not relevant
        return TET10;
      }

    case HEX8:
      {
        // see below how this correlates with INFHEX8
        if (full_ordered)
          return HEX27;
        else
          return HEX20;
      }

    case PRISM6:
      {
        if (full_ordered)
          return PRISM18;
        else
          return PRISM15;
      }

    case PYRAMID5:
      {
        if (full_ordered)
          return PYRAMID14;
        else
          return PYRAMID13;

        return INVALID_ELEM;
      }



#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

      // infinite elements
    case INFEDGE2:
      {
        return INVALID_ELEM;
      }

    case INFQUAD4:
      {
        // full_ordered not relevant
        return INFQUAD6;
      }

    case INFHEX8:
      {
        /*
         * Note that this matches with \p Hex8:
         * For full-ordered, \p InfHex18 and \p Hex27
         * belong together, and for not full-ordered,
         * \p InfHex16 and \p Hex20 belong together.
         */
        if (full_ordered)
          return INFHEX18;
        else
          return INFHEX16;
      }

    case INFPRISM6:
      {
        // full_ordered not relevant
        return INFPRISM12;
      }

#endif


    default:
      {
        // second-order element
        return INVALID_ELEM;
      }
    }
}

void libMesh::DofObject::set_buffer ( const std::vector< dof_id_type > & buf ) [inline, inherited]

Definition at line 499 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

  { _idx_buf = buf; }

void libMesh::DofObject::set_dof_number	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	comp,
		const dof_id_type	dn
	)		`[inherited]`

Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject

Definition at line 407 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

{
  libmesh_assert_less (s,    this->n_systems());
  libmesh_assert_less (var,  this->n_vars(s));
  libmesh_assert_less (comp, this->n_comp(s,var));

  const unsigned int
    vg            = this->var_to_vg(s,var),
#ifndef NDEBUG
    ncg           = this->n_comp_group(s,vg),
#endif
    vig           = this->system_var_to_vg_var(s,vg,var),
    start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());

  dof_id_type &base_idx = _idx_buf[start_idx_sys + 2*vg + 1];

  // We intend to change all dof numbers together or not at all
  if (comp || vig)
    libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
                    (dn == base_idx + vig*ncg + comp));

  // only explicitly store the base index for vig==0, comp==0
  else
    base_idx = dn;

  // #ifdef DEBUG
  //   libMesh::out << " [ ";
  //   for (unsigned int i=0; i<_idx_buf.size(); i++)
  //     libMesh::out << _idx_buf[i] << " ";
  //   libMesh::out << "]\n";
  // #endif

  libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
}

dof_id_type & libMesh::DofObject::set_id ( ) [inline, inherited]

Returns:: the id for this DofObject as a writeable reference.

Definition at line 628 of file dof_object.h.

References libMesh::DofObject::_id.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::SerialMesh::add_elem(), libMesh::ParallelMesh::add_elem(), libMesh::SerialMesh::add_node(), libMesh::ParallelMesh::add_node(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::DofObject::invalidate_id(), libMesh::Node::Node(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::LegacyXdrIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::RemoteElem::RemoteElem(), libMesh::SerialMesh::renumber_elem(), libMesh::ParallelMesh::renumber_elem(), libMesh::SerialMesh::renumber_node(), libMesh::ParallelMesh::renumber_node(), libMesh::SerialMesh::renumber_nodes_and_elements(), libMesh::SerialMesh::stitching_helper(), and libMesh::Parallel::unpack().

{
  return _id;
}

void libMesh::DofObject::set_id ( const dof_id_type dofid ) [inline, inherited]

Sets the id for this DofObject

Definition at line 161 of file dof_object.h.

References libMesh::DofObject::set_id().

Referenced by libMesh::DofObject::set_id().

  { this->set_id() = dofid; }

void libMesh::Elem::set_interior_parent ( Elem * p ) [inline, inherited]

Sets the pointer to the element's interior_parent. Dangerous to use in high-level code.

Definition at line 1749 of file elem.h.

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), libMesh::libmesh_assert(), and libMesh::Elem::n_sides().

Referenced by libMesh::BoundaryInfo::sync().

{
  // interior parents make no sense for full-dimensional elements.
  libmesh_assert_less (this->dim(), LIBMESH_DIM);

  // this had better be a one-higher-dimensional interior element
  libmesh_assert (!p ||
                  p->dim() == (this->dim()+1));

  _elemlinks[1+this->n_sides()] = p;
}

void libMesh::DofObject::set_n_comp	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	ncomp
	)		`[inherited]`

Sets the number of components for Variable var of system s associated with this DofObject

Definition at line 338 of file dof_object.C.

References libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::var_to_vg().

{
  libmesh_assert_less (s,   this->n_systems());
  libmesh_assert_less (var, this->n_vars(s));

  this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
}

void libMesh::DofObject::set_n_comp_group	(	const unsigned int	s,
		const unsigned int	vg,
		const unsigned int	ncomp
	)		`[inherited]`

Sets the number of components for VariableGroup vg of system s associated with this DofObject

Definition at line 350 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::ncv_magic, and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::reinit(), libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));

  // Check for trivial return
  if (ncomp == this->n_comp_group(s,vg)) return;

#ifndef NDEBUG
  if (ncomp >= ncv_magic)
    {
      const index_t ncvm = ncv_magic;
      libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
                        << "ncomp = "                                   \
                        << ncomp                                \
                        << ", ncv_magic = "                     \
                        << ncvm                                 \
                        << "\nrecompile and try again!");
    }
#endif

  const unsigned int
    start_idx_sys = this->start_idx(s),
    n_vars_group  = this->n_vars(s,vg),
    base_offset   = start_idx_sys + 2*vg;

  libmesh_assert_less ((base_offset + 1), _idx_buf.size());

  // if (ncomp)
  //   libMesh::out << "s,vg,ncomp="
  //       << s  << ","
  //       << vg << ","
  //       << ncomp << '\n';

  // set the number of components, maintaining the number
  // of variables in the group
  _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;

  // We use (invalid_id - 1) to signify no
  // components for this object
  _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;

  // this->debug_buffer();
  // libMesh::out << "s,vg = " << s << "," << vg << '\n'
  //     << "base_offset=" << base_offset << '\n'
  //     << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
  //     << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
  //     << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
  //     << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';

  libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
}

void libMesh::DofObject::set_n_systems ( const unsigned int s ) [inherited]

Sets the number of systems for this DofObject

Definition at line 157 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_dofs(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::n_vars().

Referenced by libMesh::DofObject::add_system(), and libMesh::Elem::refine().

{
  // Check for trivial return
  if (ns == this->n_systems())
    return;

  // Clear any existing data.  This is safe to call
  // even if we don't have any data.
  this->clear_dofs();

  // Set the new number of systems
  _idx_buf.resize(ns, ns);
  _idx_buf[0] = ns;


#ifdef DEBUG

  // check that all systems now exist and that they have 0 size
  libmesh_assert_equal_to (ns, this->n_systems());
  for (unsigned int s=0; s<this->n_systems(); s++)
    {
      libmesh_assert_equal_to (this->n_vars(s),       0);
      libmesh_assert_equal_to (this->n_var_groups(s), 0);
    }

#endif
}

void libMesh::DofObject::set_n_vars_per_group	(	const unsigned int	s,
		const std::vector< unsigned int > &	nvpg
	)		`[inherited]`

Sets number of variables in each group associated with system s for this DofObject. Implicit in this is salso setting the number of VariableGroup variable groups for the system. Has the effect of setting the number of components to 0 even when called even with (nvg == this->n_var_groups(s)).

Definition at line 219 of file dof_object.C.

References libMesh::DofObject::_idx_buf, end, libMesh::DofObject::end_idx(), libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::ncv_magic, libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::start_idx().

{

  libmesh_assert_less (s, this->n_systems());

  // number of varaible groups for this system - inferred
  const unsigned int nvg = cast_int<unsigned int>(nvpg.size());

  // BSK - note that for compatibility with the previous implementation
  // calling this method when (nvars == this->n_vars()) requires that
  // we invalidate the DOF indices and set the number of components to 0.
  // Note this was a bit of a suprise to me - there was no quick return in
  // the old method, which caused removal and readdition of the DOF indices
  // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
  // implicitly becoming 0 regardless of any previous value.
  // quick return?
  if (nvg == this->n_var_groups(s))
    {
      for (unsigned int vg=0; vg<nvg; vg++)
        {
          this->set_n_comp_group(s,vg,0);
          libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
        }
      return;
    }

  // since there is ample opportunity to screw up other systems, let us
  // cache their current sizes and later assert that they are unchanged.
#ifdef DEBUG
  DofObject::index_buffer_t old_system_sizes;
  old_system_sizes.reserve(this->n_systems());

  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
    old_system_sizes.push_back(this->n_var_groups(s_ctr));
#endif

  // remove current indices if we have some
  if (this->n_var_groups(s) != 0)
    {
      const unsigned int old_nvg_s = this->n_var_groups(s);

      DofObject::index_buffer_t::iterator
        it  = _idx_buf.begin(),
        end = _idx_buf.begin();

      std::advance(it,  this->start_idx(s));
      std::advance(end, this->end_idx(s));
      _idx_buf.erase(it,end);

      for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
        _idx_buf[ctr] -= 2*old_nvg_s;
    }

  // better not have any now!
  libmesh_assert_equal_to (this->n_var_groups(s), 0);

  // had better not screwed up any of our sizes!
#ifdef DEBUG
  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
    if (s_ctr != s)
      libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
#endif

  // OK, if the user requested 0 that is what we have
  if (nvg == 0)
    return;

  {
    // array to hold new indices
    DofObject::index_buffer_t var_idxs(2*nvg);
    for (unsigned int vg=0; vg<nvg; vg++)
      {
        var_idxs[2*vg    ] = ncv_magic*nvpg[vg] + 0;
        var_idxs[2*vg + 1] = invalid_id - 1;
      }

    DofObject::index_buffer_t::iterator it = _idx_buf.begin();
    std::advance(it, this->end_idx(s));
    _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());

    for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
      _idx_buf[ctr] += 2*nvg;

    // resize _idx_buf to fit so no memory is wasted.
    DofObject::index_buffer_t(_idx_buf).swap(_idx_buf);
  }

  // that better had worked.  Assert stuff.
  libmesh_assert_equal_to (nvg, this->n_var_groups(s));

#ifdef DEBUG

  // libMesh::out << " [ ";
  // for (unsigned int i=0; i<_idx_buf.size(); i++)
  //   libMesh::out << _idx_buf[i] << " ";
  // libMesh::out << "]\n";

  libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());

  for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
    {
      libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
      libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
    }

  for (unsigned int v=0; v<this->n_vars(s); v++)
    libmesh_assert_equal_to (this->n_comp(s,v), 0);

  // again, all other system sizes shoudl be unchanged!
  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
    if (s_ctr != s)
      libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);

#endif
}

void libMesh::Elem::set_neighbor	(	const unsigned int	i,
		Elem *	n
	)		`[inline, inherited]`

Assigns n as the $i^{th}$ neighbor.

Definition at line 1463 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::nullify_neighbors(), libMesh::SerialMesh::stitching_helper(), and libMesh::Parallel::unpack().

{
  libmesh_assert_less (i, this->n_neighbors());

  _elemlinks[i+1] = n;
}

Node *& libMesh::Elem::set_node ( const unsigned int i ) [inline, virtual, inherited]

Returns:: the pointer to local Node i as a writeable reference.

Reimplemented in libMesh::RemoteElem.

Definition at line 1427 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());

  return _nodes[i];
}

void libMesh::DofObject::set_old_dof_object ( ) [inherited]

Sets the old_dof_object to a copy of this

Definition at line 142 of file dof_object.C.

References libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::DofObject(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

Referenced by libMesh::DofMap::reinit().

{
  this->clear_old_dof_object();

  libmesh_assert (!this->old_dof_object);

  // Make a new DofObject, assign a copy of \p this.
  // Make sure the copy ctor for DofObject works!!
  this->old_dof_object = new DofObject(*this);
}

void libMesh::Elem::set_p_level ( const unsigned int p ) [inline, inherited]

Sets the value of the p refinement level for the element Note that the maximum p refinement level is currently 255

Definition at line 1900 of file elem.h.

References libMesh::Elem::_p_level, libMesh::Elem::child(), std::min(), libMesh::Elem::n_children(), libMesh::Elem::p_level(), libMesh::Elem::parent(), and libMesh::Elem::set_p_level().

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshRefinement::_refine_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::Elem(), libMesh::Elem::refine(), libMesh::DofMap::reinit(), libMesh::Elem::set_p_level(), and libMesh::Parallel::unpack().

{
  // Maintain the parent's p level as the minimum of it's children
  if (this->parent() != NULL)
    {
      unsigned int parent_p_level = this->parent()->p_level();

      // If our new p level is less than our parents, our parents drops
      if (parent_p_level > p)
        {
          this->parent()->set_p_level(p);
        }
      // If we are the lowest p level and it increases, so might
      // our parent's, but we have to check every other child to see
      else if (parent_p_level == _p_level && _p_level < p)
        {
          _p_level = cast_int<unsigned char>(p);
          parent_p_level = cast_int<unsigned char>(p);
          for (unsigned int c=0; c != this->parent()->n_children(); c++)
            parent_p_level = std::min(parent_p_level,
                                      this->parent()->child(c)->p_level());

          if (parent_p_level != this->parent()->p_level())
            this->parent()->set_p_level(parent_p_level);

          return;
        }
    }

  _p_level = cast_int<unsigned char>(p);
}

void libMesh::Elem::set_p_refinement_flag ( const RefinementState pflag ) [inline, inherited]

Sets the value of the p refinement flag for the element.

Definition at line 1874 of file elem.h.

References libMesh::Elem::_pflag.

{
  _pflag = cast_int<unsigned char>(pflag);
}

void libMesh::Elem::set_parent ( Elem * p ) [inline, inherited]

Sets the pointer to the element's parent. Dangerous to use in high-level code.

Definition at line 1699 of file elem.h.

References libMesh::Elem::_elemlinks.

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::BoundaryInfo::sync().

{
  _elemlinks[0] = p;
}

void libMesh::Elem::set_refinement_flag ( const RefinementState rflag ) [inline, inherited]

Sets the value of the refinement flag for the element.

Definition at line 1858 of file elem.h.

References libMesh::Elem::_rflag.

{
  _rflag = cast_int<RefinementState>(rflag);
}

unique_id_type & libMesh::DofObject::set_unique_id ( ) [inline, inherited]

Returns:: the globally unique_id for this DofObject as a writeable reference.

Definition at line 649 of file dof_object.h.

References libMesh::DofObject::_unique_id.

Referenced by libMesh::SerialMesh::add_elem(), libMesh::ParallelMesh::add_elem(), libMesh::SerialMesh::add_node(), libMesh::ParallelMesh::add_node(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::unpack().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  return _unique_id;
#else
  libmesh_not_implemented();
#endif
}

void libMesh::DofObject::set_vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg,
		const dof_id_type	db
	)		`[inline, inherited]`

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 889 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::start_idx(), and libMesh::DofObject::vg_dof_base().

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::invalidate_dofs(), libMesh::DofMap::reinit(), and libMesh::DofMap::set_nonlocal_dof_objects().

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));

  const unsigned int
    start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());

  _idx_buf[start_idx_sys + 2*vg + 1] = db;

  libmesh_assert_equal_to (this->vg_dof_base(s,vg), db);
}

UniquePtr< Elem > libMesh::Pyramid::side ( const unsigned int i ) const [virtual, inherited]

Returns:: a primitive triangle or quad for face i.

Implements libMesh::Elem.

Definition at line 85 of file cell_pyramid.C.

References libMesh::Elem::get_node(), libMesh::Pyramid::n_sides(), and libMesh::Elem::set_node().

{
  libmesh_assert_less (i, this->n_sides());

  // To be returned wrapped in an UniquePtr
  Elem* face = NULL;

  switch (i)
    {
    case 0:  // triangular face 1
      {
        face = new Tri3;

        face->set_node(0) = this->get_node(0);
        face->set_node(1) = this->get_node(1);
        face->set_node(2) = this->get_node(4);

        break;
      }
    case 1:  // triangular face 2
      {
        face = new Tri3;

        face->set_node(0) = this->get_node(1);
        face->set_node(1) = this->get_node(2);
        face->set_node(2) = this->get_node(4);

        break;
      }
    case 2:  // triangular face 3
      {
        face = new Tri3;

        face->set_node(0) = this->get_node(2);
        face->set_node(1) = this->get_node(3);
        face->set_node(2) = this->get_node(4);

        break;
      }
    case 3:  // triangular face 4
      {
        face = new Tri3;

        face->set_node(0) = this->get_node(3);
        face->set_node(1) = this->get_node(0);
        face->set_node(2) = this->get_node(4);

        break;
      }
    case 4:  // the quad face at z=0
      {
        face = new Quad4;

        face->set_node(0) = this->get_node(0);
        face->set_node(1) = this->get_node(3);
        face->set_node(2) = this->get_node(2);
        face->set_node(3) = this->get_node(1);

        break;
      }
    default:
      libmesh_error_msg("Invalid side i = " << i);
    }

  return UniquePtr<Elem>(face);
}

unsigned int libMesh::Pyramid::side_children_matrix	(	const unsigned	int,
		const unsigned	int
	)		const `[inline, protected, inherited]`

Matrix that allows children to inherit boundary conditions.

Definition at line 117 of file cell_pyramid.h.

  { libmesh_not_implemented(); return 0; }

bool libMesh::Elem::subactive ( ) const [inline, inherited]

Returns:: true if the element is subactive (i.e. has no active descendants), false otherwise. Always returns false if AMR is disabled.

Definition at line 1612 of file elem.h.

References libMesh::Elem::active(), libMesh::Elem::has_children(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::active_family_tree(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::active_family_tree_by_side(), libMesh::HPCoarsenTest::add_projection(), libMesh::FEAbstract::compute_node_constraints(), libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::Elem::family_tree(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::MeshTools::get_not_subactive_node_ids(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::SerialMesh::stitching_helper(), and libMesh::LegacyXdrIO::write_mesh().

{
#ifdef LIBMESH_ENABLE_AMR
  if (this->active())
    return false;
  if (!this->has_children())
    return true;
  for (const Elem* my_ancestor = this->parent();
       my_ancestor != NULL;
       my_ancestor = my_ancestor->parent())
    if (my_ancestor->active())
      return true;
#endif

  return false;
}

subdomain_id_type libMesh::Elem::subdomain_id ( ) const [inline, inherited]

Returns:: the subdomain that this element belongs to.

Definition at line 1437 of file elem.h.

References libMesh::Elem::_sbd_id.

{
  return _sbd_id;
}

subdomain_id_type & libMesh::Elem::subdomain_id ( ) [inline, inherited]

Returns:: the subdomain that this element belongs to as a writeable reference.

Definition at line 1445 of file elem.h.

References libMesh::Elem::_sbd_id.

{
  return _sbd_id;
}

const Elem * libMesh::Elem::top_parent ( ) const [inline, inherited]

Returns:: a pointer to the element's top-most (i.e. level-0) parent. Returns this if this is a level-0 element, this element's parent if this is a level-1 element, this element's grandparent if this is a level-2 element, etc...

Definition at line 1707 of file elem.h.

References libMesh::Elem::level(), libMesh::libmesh_assert(), and libMesh::Elem::parent().

Referenced by libMesh::BoundaryInfo::boundary_id(), libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::BoundaryInfo::n_boundary_ids(), libMesh::BoundaryInfo::n_edge_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), and libMesh::BoundaryInfo::sync().

{
  const Elem* tp = this;

  // Keep getting the element's parent
  // until that parent is at level-0
  while (tp->parent() != NULL)
    tp = tp->parent();

  libmesh_assert(tp);
  libmesh_assert_equal_to (tp->level(), 0);

  return tp;
}

const Elem * libMesh::Elem::topological_neighbor	(	const unsigned int	i,
		const MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		const PeriodicBoundaries *	pb
	)		const `[inherited]`

Returns:: a pointer to the $i^{th}$ neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 909 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshBase::elem(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::has_topological_neighbor(), and libMesh::MeshRefinement::topological_neighbor().

{
  libmesh_assert_less (i, this->n_neighbors());

  const Elem * neighbor_i = this->neighbor(i);
  if (neighbor_i != NULL)
    return neighbor_i;

  if (pb)
    {
      // Since the neighbor is NULL it must be on a boundary. We need
      // see if this is a periodic boundary in which case it will have a
      // topological neighbor

      std::vector<boundary_id_type> boundary_ids =
        mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i));
      for (std::vector<boundary_id_type>::iterator j = boundary_ids.begin(); j != boundary_ids.end(); ++j)
        if (pb->boundary(*j))
          {
            // Since the point locator inside of periodic boundaries
            // returns a const pointer we will retrieve the proper
            // pointer directly from the mesh object.  Also since coarse
            // elements do not have more refined neighbors we need to make
            // sure that we don't return one of these types of neighbors.
            neighbor_i = mesh.elem(pb->neighbor(*j, point_locator, this, i)->id());
            if (level() < neighbor_i->level())
              neighbor_i = neighbor_i->parent();
            return neighbor_i;
          }
    }

  return NULL;
}

Elem * libMesh::Elem::topological_neighbor	(	const unsigned int	i,
		MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		const PeriodicBoundaries *	pb
	)		`[inherited]`

Returns:: a writeable pointer to the $i^{th}$ neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 870 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshBase::elem(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor(), and libMesh::Elem::parent().

{
  libmesh_assert_less (i, this->n_neighbors());

  Elem * neighbor_i = this->neighbor(i);
  if (neighbor_i != NULL)
    return neighbor_i;

  if (pb)
    {
      // Since the neighbor is NULL it must be on a boundary. We need
      // see if this is a periodic boundary in which case it will have a
      // topological neighbor

      std::vector<boundary_id_type> boundary_ids =
        mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i));
      for (std::vector<boundary_id_type>::iterator j = boundary_ids.begin(); j != boundary_ids.end(); ++j)
        if (pb->boundary(*j))
          {
            // Since the point locator inside of periodic boundaries
            // returns a const pointer we will retrieve the proper
            // pointer directly from the mesh object.  Also since coarse
            // elements do not have more refined neighbors we need to make
            // sure that we don't return one of these types of neighbors.
            neighbor_i = mesh.elem(pb->neighbor(*j, point_locator, this, i)->id());
            if (level() < neighbor_i->level())
              neighbor_i = neighbor_i->parent();
            return neighbor_i;
          }
    }

  return NULL;
}

void libMesh::Elem::total_family_tree	(	std::vector< const Elem * > &	active_family,
		const bool	reset = `true`
	)		const `[inherited]`

Same as the family_tree() member, but also adds any subactive descendants.

Definition at line 1440 of file elem.C.

References libMesh::Elem::child(), libMesh::Elem::has_children(), libMesh::Elem::is_remote(), libMesh::Elem::n_children(), and libMesh::Elem::total_family_tree().

Referenced by libMesh::Partitioner::set_parent_processor_ids(), and libMesh::Elem::total_family_tree().

{
  // Clear the vector if the flag reset tells us to.
  if (reset)
    family.clear();

  // Add this element to the family tree.
  family.push_back(this);

  // Recurse into the elements children, if it has them.
  // Do not clear the vector any more.
  if (this->has_children())
    for (unsigned int c=0; c<this->n_children(); c++)
      if (!this->child(c)->is_remote())
        this->child(c)->total_family_tree (family, false);
}

ElemType libMesh::Pyramid5::type ( ) const [inline, virtual]

Returns:: PRYAMID

Implements libMesh::Elem.

Definition at line 66 of file cell_pyramid5.h.

References libMesh::PYRAMID5.

{ return PYRAMID5; }

unique_id_type libMesh::DofObject::unique_id ( ) const [inline, inherited]

Returns:: the globally unique_id for this DofObject

Definition at line 636 of file dof_object.h.

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::Parallel::pack(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::write_connectivity(), and libMesh::CheckpointIO::write_nodes().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  libmesh_assert (this->valid_unique_id());
  return _unique_id;
#else
  return invalid_unique_id;
#endif
}

void libMesh::DofObject::unpack_indexing ( std::vector< largest_id_type >::const_iterator begin ) [inherited]

A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy.

Definition at line 487 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::DofObject(), libMesh::libmesh_assert(), libMesh::DofObject::old_dof_object, and libMesh::DofObject::unpack_indexing().

Referenced by libMesh::Parallel::unpack(), and libMesh::DofObject::unpack_indexing().

{
  _idx_buf.clear();

#ifdef LIBMESH_ENABLE_AMR
  this->clear_old_dof_object();
  const bool has_old_dof_object = cast_int<bool>(*begin++);
#endif

  const largest_id_type size = *begin++;
  _idx_buf.reserve(size);
  std::copy(begin, begin+size, back_inserter(_idx_buf));

  // Check as best we can for internal consistency now
  libmesh_assert(_idx_buf.empty() ||
                 (_idx_buf[0] <= _idx_buf.size()));
#ifdef DEBUG
  if (!_idx_buf.empty())
    for (unsigned int i=1; i < _idx_buf[0]; ++i)
      {
        libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
        libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
        libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
      }
#endif

#ifdef LIBMESH_ENABLE_AMR
  if (has_old_dof_object)
    {
      this->old_dof_object = new DofObject();
      this->old_dof_object->unpack_indexing(begin+size);
    }
#endif
}

unsigned int libMesh::DofObject::unpackable_indexing_size ( std::vector< largest_id_type >::const_iterator begin ) [static, inherited]

If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Definition at line 466 of file dof_object.C.

Referenced by libMesh::Parallel::pack(), libMesh::Parallel::packed_size(), and libMesh::Parallel::unpack().

{
#ifdef LIBMESH_ENABLE_AMR
  const bool has_old_dof_object = cast_int<bool>(*begin++);

  static const int dof_header_size = 2;
#else
  static const bool has_old_dof_object = false;
  static const int dof_header_size = 1;
#endif

  const largest_id_type this_indexing_size = *begin++;

  return cast_int<unsigned int>
    (dof_header_size + this_indexing_size +
     (has_old_dof_object ?
      unpackable_indexing_size(begin+this_indexing_size) : 0));
}

bool libMesh::DofObject::valid_id ( ) const [inline, inherited]

Returns:: true if this DofObject has a valid id set, false otherwise.

Definition at line 661 of file dof_object.h.

References libMesh::DofObject::_id, and libMesh::DofObject::invalid_id.

Referenced by libMesh::SerialMesh::add_elem(), libMesh::ParallelMesh::add_elem(), libMesh::SerialMesh::add_node(), libMesh::ParallelMesh::add_node(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofObject::id(), and libMesh::Elem::libmesh_assert_valid_node_pointers().

{
  return (DofObject::invalid_id != _id);
}

bool libMesh::DofObject::valid_processor_id ( ) const [inline, inherited]

Returns:: true if this DofObject has a valid id set, false otherwise.

Definition at line 705 of file dof_object.h.

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

{
  return (DofObject::invalid_processor_id != _processor_id);
}

bool libMesh::DofObject::valid_unique_id ( ) const [inline, inherited]

Returns:: true if this DofObject has a valid unique_id set, false otherwise.

Definition at line 669 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

Referenced by libMesh::SerialMesh::add_elem(), libMesh::ParallelMesh::add_elem(), libMesh::SerialMesh::add_node(), libMesh::ParallelMesh::add_node(), libMesh::Parallel::pack(), and libMesh::DofObject::unique_id().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  return (DofObject::invalid_unique_id != _unique_id);
#else
  return false;
#endif
}

dof_id_type libMesh::DofObject::vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg
	)		const `[inline, inherited]`

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 909 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), and libMesh::DofObject::set_vg_dof_base().

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));

  const unsigned int
    start_idx_sys = this->start_idx(s);

  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());

  // #ifdef DEBUG
  //   std::cout << " [ ";
  //   for (unsigned int i=0; i<_idx_buf.size(); i++)
  //     std::cout << _idx_buf[i] << " ";
  //   std::cout << "]\n";
  // #endif

  return _idx_buf[start_idx_sys + 2*vg + 1];
}

Real libMesh::Pyramid5::volume ( ) const [virtual]

Specialization for computing the volume of a pyramid.

Reimplemented from libMesh::Elem.

Definition at line 253 of file cell_pyramid5.C.

References libMesh::TypeVector< T >::cross(), and libMesh::Elem::get_node().

{
  // The pyramid with a bilinear base has volume given by the
  // formula in: "Calculation of the Volume of a General Hexahedron
  // for Flow Predictions", AIAA Journal v.23, no.6, 1984, p.954-
  Node* node0 = this->get_node(0);
  Node* node1 = this->get_node(1);
  Node* node2 = this->get_node(2);
  Node* node3 = this->get_node(3);
  Node* node4 = this->get_node(4);

  // Construct Various edge and diagonal vectors
  Point v40 ( *node0 - *node4 );
  Point v13 ( *node3 - *node1 );
  Point v02 ( *node2 - *node0 );
  Point v03 ( *node3 - *node0 );
  Point v01 ( *node1 - *node0 );

  // Finally, ready to return the volume!
  return (1./6.)*(v40*(v13.cross(v02))) + (1./12.)*(v02*(v01.cross(v03)));
}

unsigned int libMesh::Elem::which_child_am_i ( const Elem * e ) const [inline, inherited]

This function tells you which child you (e) are. I.e. if c = a->which_child_am_i(e); then a->child(c) will be e;

Definition at line 1833 of file elem.h.

References libMesh::Elem::child(), libMesh::Elem::has_children(), libMesh::invalid_uint, libMesh::libmesh_assert(), and libMesh::Elem::n_children().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::BoundaryInfo::boundary_id(), libMesh::BoundaryInfo::boundary_ids(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::Elem::make_links_to_me_remote(), libMesh::BoundaryInfo::n_boundary_ids(), libMesh::BoundaryInfo::n_edge_boundary_ids(), libMesh::Parallel::pack(), libMesh::BoundaryInfo::side_with_boundary_id(), and libMesh::Parallel::sync_element_data_by_parent_id().

{
  libmesh_assert(e);
  libmesh_assert (this->has_children());

  for (unsigned int c=0; c<this->n_children(); c++)
    if (this->child(c) == e)
      return c;

  libmesh_error_msg("ERROR:  which_child_am_i() was called with a non-child!");

  return libMesh::invalid_uint;
}

unsigned int libMesh::Elem::which_neighbor_am_i ( const Elem * e ) const [inline, inherited]

This function tells you which neighbor you (e) are. I.e. if s = a->which_neighbor_am_i(e); then a->neighbor(s) will be an ancestor of e;

Definition at line 1521 of file elem.h.

References libMesh::invalid_uint, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor(), and libMesh::Elem::parent().

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::ParmetisPartitioner::build_graph(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_remote(), and libMesh::Elem::nullify_neighbors().

{
  libmesh_assert(e);

  const Elem* eparent = e;

  while (eparent->level() > this->level())
    {
      eparent = eparent->parent();
      libmesh_assert(eparent);
    }

  for (unsigned int s=0; s<this->n_neighbors(); s++)
    if (this->neighbor(s) == eparent)
      return s;

  return libMesh::invalid_uint;
}

unsigned int libMesh::Elem::which_side_am_i ( const Elem * e ) const [inline, inherited]

This function tells you which side the boundary element e is. I.e. if e = a->build_side(s) or e = a->side(s); then a->which_side_am_i(e) will be s.

Returns invalid_uint if e is not a side of this

Definition at line 1543 of file elem.h.

References libMesh::invalid_uint, libMesh::Elem::is_node_on_side(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), and libMesh::Elem::point().

{
  libmesh_assert(e);

  const unsigned int ns = this->n_sides();
  const unsigned int nn = this->n_nodes();

  const unsigned int en = e->n_nodes();

  // e might be on any side until proven otherwise
  std::vector<bool> might_be_side(ns, true);

  for (unsigned int i=0; i != en; ++i)
    {
      Point side_point = e->point(i);
      unsigned int local_node_id = libMesh::invalid_uint;

      // Look for a node of this that's contiguous with node i of e
      for (unsigned int j=0; j != nn; ++j)
        if (this->point(j) == side_point)
          local_node_id = j;

      // If a node of e isn't contiguous with some node of this, then
      // e isn't a side of this.
      if (local_node_id == libMesh::invalid_uint)
        return libMesh::invalid_uint;

      // If a node of e isn't contiguous with some node on side s of
      // this, then e isn't on side s.
      for (unsigned int s=0; s != ns; ++s)
        if (!this->is_node_on_side(local_node_id, s))
          might_be_side[s] = false;
    }

  for (unsigned int s=0; s != ns; ++s)
    if (might_be_side[s])
      {
#ifdef DEBUG
        for (unsigned int s2=s+1; s2 < ns; ++s2)
          libmesh_assert (!might_be_side[s2]);
#endif
        return s;
      }

  // Didn't find any matching side
  return libMesh::invalid_uint;
}

void libMesh::Elem::write_connectivity	(	std::ostream &	out,
		const IOPackage	iop
	)		const `[inherited]`

Writes the element connectivity for various IO packages to the passed ostream "out". Not virtual, since it is implemented in the base class. This function supercedes the write_tecplot_connectivity(...) and write_ucd_connectivity(...) routines.

Definition at line 1255 of file elem.C.

References libMesh::Elem::_nodes, libMesh::Elem::connectivity(), libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sub_elem(), libMesh::Elem::node(), libMesh::TECPLOT, and libMesh::UCD.

{
  libmesh_assert (out_stream.good());
  libmesh_assert(_nodes);
  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);

  switch (iop)
    {
    case TECPLOT:
      {
        // This connectivity vector will be used repeatedly instead
        // of being reconstructed inside the loop.
        std::vector<dof_id_type> conn;
        for (unsigned int sc=0; sc <this->n_sub_elem(); sc++)
          {
            this->connectivity(sc, TECPLOT, conn);

            std::copy(conn.begin(),
                      conn.end(),
                      std::ostream_iterator<dof_id_type>(out_stream, " "));

            out_stream << '\n';
          }
        return;
      }

    case UCD:
      {
        for (unsigned int i=0; i<this->n_nodes(); i++)
          out_stream << this->node(i)+1 << "\t";

        out_stream << '\n';
        return;
      }

    default:
      libmesh_error_msg("Unsupported IO package " << iop);
    }
}

Member Data Documentation

Elem** libMesh::Elem::_children [protected, inherited]

Pointers to this element's children.

Definition at line 1223 of file elem.h.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::child(), libMesh::Elem::contract(), libMesh::Elem::has_ancestor_children(), libMesh::Elem::has_children(), libMesh::Elem::refine(), libMesh::Elem::set_child(), and libMesh::Elem::~Elem().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

Elem** libMesh::Elem::_elemlinks [protected, inherited]

Pointers to this element's parent and neighbors, and for lower-dimensional elements interior_parent.

Definition at line 1217 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::interior_parent(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), and libMesh::Elem::set_parent().

Elem* libMesh::Pyramid::_elemlinks_data[6+(LIBMESH_DIM >3)] [protected, inherited]

Data for links to parent/neighbor/interior_parent elements.

Definition at line 109 of file cell_pyramid.h.

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

Node* libMesh::Pyramid5::_nodelinks_data[5] [protected]

Data for links to nodes

Definition at line 153 of file cell_pyramid5.h.

Node** libMesh::Elem::_nodes [protected, inherited]

Pointers to the nodes we are connected to.

Definition at line 1211 of file elem.h.

unsigned char libMesh::Elem::_p_level [protected, inherited]

p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh. This is stored as an unsigned char to save space. In theory, these last four bytes might have been padding anyway.

Definition at line 1254 of file elem.h.

Referenced by libMesh::Elem::hack_p_level(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::p_level(), and libMesh::Elem::set_p_level().

unsigned char libMesh::Elem::_pflag [protected, inherited]

p refinement flag. This is stored as an unsigned char to save space.

Definition at line 1243 of file elem.h.

Referenced by libMesh::Elem::p_refinement_flag(), and libMesh::Elem::set_p_refinement_flag().

unsigned char libMesh::Elem::_rflag [protected, inherited]

h refinement flag. This is stored as an unsigned char to save space.

Definition at line 1236 of file elem.h.

Referenced by libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

subdomain_id_type libMesh::Elem::_sbd_id [protected, inherited]

The subdomain to which this element belongs.

Definition at line 1229 of file elem.h.

Referenced by libMesh::Elem::subdomain_id().

const unsigned int libMesh::Pyramid5::edge_nodes_map [static]

Initial value:

  {
    {0, 1}, 
    {1, 2}, 
    {2, 3}, 
    {0, 3}, 
    {0, 4}, 
    {1, 4}, 
    {2, 4}, 
    {3, 4}  
  }

This maps the $j^{th}$ node of the $i^{th}$ edge to element node numbers.

Definition at line 140 of file cell_pyramid5.h.

Referenced by libMesh::Pyramid::is_edge_on_side(), and is_node_on_edge().

const dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1) [static, inherited]

An invaild id to distinguish an uninitialized DofObject

Definition at line 335 of file dof_object.h.

Referenced by libMesh::SFCPartitioner::_do_partition(), libMesh::DofMap::_dof_indices(), libMesh::Node::active(), libMesh::SerialMesh::add_point(), libMesh::MeshRefinement::add_point(), libMesh::UnstructuredMesh::all_second_order(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::dof_number(), libMesh::SerialMesh::insert_node(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::Node::Node(), libMesh::Elem::node(), libMesh::DofMap::old_dof_indices(), libMesh::XdrIO::pack_element(), libMesh::Elem::point(), libMesh::System::read_legacy_data(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::unpack(), libMesh::DofObject::valid_id(), and libMesh::System::write_parallel_data().

const processor_id_type libMesh::DofObject::invalid_processor_id = static_cast<processor_id_type>(-1) [static, inherited]

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 346 of file dof_object.h.

const subdomain_id_type libMesh::Elem::invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max() [static, inherited]

A static integral constant representing an invalid subdomain id. See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note 1: we don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a *signed* integer for compatibility reasons (see libmesh/id_types.h).

Note 2: Normally you can declare static const integral types directly in the header file (C++ standard, 9.4.2/4) but std::numeric_limits<T>::max() is not considered a "constant expression". This one is therefore defined in elem.C. http://stackoverflow.com/questions/2738435/using-numeric-limitsmax-in-constant-expressions

Definition at line 182 of file elem.h.

Referenced by libMesh::MeshBase::get_id_by_name().

const unique_id_type libMesh::DofObject::invalid_unique_id = static_cast<unique_id_type>(-1) [static, inherited]

An invaild unique_id to distinguish an uninitialized DofObject

Definition at line 340 of file dof_object.h.

Referenced by libMesh::Parallel::pack(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

DofObject* libMesh::DofObject::old_dof_object [inherited]

This object on the last mesh. Useful for projecting solutions from one mesh to another.

Definition at line 89 of file dof_object.h.

Referenced by libMesh::DofObject::clear_old_dof_object(), libMesh::MeshTools::libmesh_assert_old_dof_objects(), libMesh::DofMap::old_dof_indices(), libMesh::DofObject::operator=(), libMesh::DofObject::packed_indexing_size(), libMesh::DofMap::reinit(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

const unsigned int libMesh::Pyramid5::side_nodes_map [static]

Initial value:

  {
    {0, 1, 4, 99}, 
    {1, 2, 4, 99}, 
    {2, 3, 4, 99}, 
    {3, 0, 4, 99}, 
    {0, 3, 2,  1}  
  }

This maps the $j^{th}$ node of the $i^{th}$ side to element node numbers.

Definition at line 134 of file cell_pyramid5.h.

Referenced by libMesh::Pyramid::is_child_on_side(), and is_node_on_side().

const unsigned int libMesh::Elem::type_to_n_edges_map [static, inherited]

This array maps the integer representation of the ElemType enum to the number of edges on the element.

Definition at line 463 of file elem.h.

Referenced by libMesh::Parallel::packed_size().

const unsigned int libMesh::Elem::type_to_n_nodes_map [static, inherited]

This array maps the integer representation of the ElemType enum to the number of nodes in the element.

Definition at line 418 of file elem.h.

Referenced by libMesh::XdrIO::pack_element(), libMesh::Parallel::packed_size(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::unpack().

const unsigned int libMesh::Elem::type_to_n_sides_map [static, inherited]

This array maps the integer representation of the ElemType enum to the number of sides on the element.

Definition at line 429 of file elem.h.

Referenced by libMesh::Parallel::packed_size().

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation