libMesh::ReplicatedMesh Class Reference

Mesh data structure replicated on all processors. More...

#include <replicated_mesh.h>

Inheritance diagram for libMesh::ReplicatedMesh:

Public Types
typedef Predicates::multi_predicate	Predicate

Public Member Functions
	ReplicatedMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
	ReplicatedMesh (const UnstructuredMesh &other_mesh)
	ReplicatedMesh (const ReplicatedMesh &other_mesh)
	ReplicatedMesh (ReplicatedMesh &&)=default
ReplicatedMesh &	operator= (const ReplicatedMesh &)=delete
ReplicatedMesh &	operator= (ReplicatedMesh &&)=delete
virtual std::unique_ptr< MeshBase >	clone () const override
virtual	~ReplicatedMesh ()
virtual void	clear () override
virtual void	renumber_nodes_and_elements () override
virtual dof_id_type	n_nodes () const override
virtual dof_id_type	parallel_n_nodes () const override
virtual dof_id_type	max_node_id () const override
virtual void	reserve_nodes (const dof_id_type nn) override
virtual dof_id_type	n_elem () const override
virtual dof_id_type	parallel_n_elem () const override
virtual dof_id_type	n_active_elem () const override
virtual dof_id_type	max_elem_id () const override
virtual unique_id_type	parallel_max_unique_id () const override
virtual void	reserve_elem (const dof_id_type ne) override
virtual void	update_parallel_id_counts () override
virtual const Point &	point (const dof_id_type i) const override
virtual const Node *	node_ptr (const dof_id_type i) const override
virtual Node *	node_ptr (const dof_id_type i) override
virtual const Node *	query_node_ptr (const dof_id_type i) const override
virtual Node *	query_node_ptr (const dof_id_type i) override
virtual const Elem *	elem_ptr (const dof_id_type i) const override
virtual Elem *	elem_ptr (const dof_id_type i) override
virtual const Elem *	query_elem_ptr (const dof_id_type i) const override
virtual Elem *	query_elem_ptr (const dof_id_type i) override
virtual Node *	add_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id) override
virtual Node *	add_node (Node *n) override
virtual Node *	insert_node (Node *n) override
virtual void	delete_node (Node *n) override
virtual void	renumber_node (dof_id_type old_id, dof_id_type new_id) override
virtual Elem *	add_elem (Elem *e) override
virtual Elem *	insert_elem (Elem *e) override
virtual void	delete_elem (Elem *e) override
virtual void	renumber_elem (dof_id_type old_id, dof_id_type new_id) override
virtual void	fix_broken_node_and_element_numbering () override
void	stitch_meshes (const ReplicatedMesh &other_mesh, boundary_id_type this_mesh_boundary, boundary_id_type other_mesh_boundary, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false)
void	stitch_surfaces (boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false)
virtual element_iterator	elements_begin () override
virtual element_iterator	elements_end () override
virtual const_element_iterator	elements_begin () const override
virtual const_element_iterator	elements_end () const override
virtual SimpleRange< element_iterator >	element_ptr_range () override
virtual SimpleRange< const_element_iterator >	element_ptr_range () const override
virtual element_iterator	active_elements_begin () override
virtual element_iterator	active_elements_end () override
virtual const_element_iterator	active_elements_begin () const override
virtual const_element_iterator	active_elements_end () const override
virtual SimpleRange< element_iterator >	active_element_ptr_range () override
virtual SimpleRange< const_element_iterator >	active_element_ptr_range () const override
virtual element_iterator	ancestor_elements_begin () override
virtual element_iterator	ancestor_elements_end () override
virtual const_element_iterator	ancestor_elements_begin () const override
virtual const_element_iterator	ancestor_elements_end () const override
virtual element_iterator	subactive_elements_begin () override
virtual element_iterator	subactive_elements_end () override
virtual const_element_iterator	subactive_elements_begin () const override
virtual const_element_iterator	subactive_elements_end () const override
virtual element_iterator	not_active_elements_begin () override
virtual element_iterator	not_active_elements_end () override
virtual const_element_iterator	not_active_elements_begin () const override
virtual const_element_iterator	not_active_elements_end () const override
virtual element_iterator	not_ancestor_elements_begin () override
virtual element_iterator	not_ancestor_elements_end () override
virtual const_element_iterator	not_ancestor_elements_begin () const override
virtual const_element_iterator	not_ancestor_elements_end () const override
virtual element_iterator	not_subactive_elements_begin () override
virtual element_iterator	not_subactive_elements_end () override
virtual const_element_iterator	not_subactive_elements_begin () const override
virtual const_element_iterator	not_subactive_elements_end () const override
virtual element_iterator	local_elements_begin () override
virtual element_iterator	local_elements_end () override
virtual const_element_iterator	local_elements_begin () const override
virtual const_element_iterator	local_elements_end () const override
virtual element_iterator	semilocal_elements_begin () override
virtual element_iterator	semilocal_elements_end () override
virtual const_element_iterator	semilocal_elements_begin () const override
virtual const_element_iterator	semilocal_elements_end () const override
virtual element_iterator	active_semilocal_elements_begin () override
virtual element_iterator	active_semilocal_elements_end () override
virtual const_element_iterator	active_semilocal_elements_begin () const override
virtual const_element_iterator	active_semilocal_elements_end () const override
virtual element_iterator	facelocal_elements_begin () override
virtual element_iterator	facelocal_elements_end () override
virtual const_element_iterator	facelocal_elements_begin () const override
virtual const_element_iterator	facelocal_elements_end () const override
virtual element_iterator	not_local_elements_begin () override
virtual element_iterator	not_local_elements_end () override
virtual const_element_iterator	not_local_elements_begin () const override
virtual const_element_iterator	not_local_elements_end () const override
virtual element_iterator	active_local_elements_begin () override
virtual element_iterator	active_local_elements_end () override
virtual const_element_iterator	active_local_elements_begin () const override
virtual const_element_iterator	active_local_elements_end () const override
virtual SimpleRange< element_iterator >	active_local_element_ptr_range () override
virtual SimpleRange< const_element_iterator >	active_local_element_ptr_range () const override
virtual element_iterator	active_not_local_elements_begin () override
virtual element_iterator	active_not_local_elements_end () override
virtual const_element_iterator	active_not_local_elements_begin () const override
virtual const_element_iterator	active_not_local_elements_end () const override
virtual element_iterator	level_elements_begin (unsigned int level) override
virtual element_iterator	level_elements_end (unsigned int level) override
virtual const_element_iterator	level_elements_begin (unsigned int level) const override
virtual const_element_iterator	level_elements_end (unsigned int level) const override
virtual element_iterator	not_level_elements_begin (unsigned int level) override
virtual element_iterator	not_level_elements_end (unsigned int level) override
virtual const_element_iterator	not_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	not_level_elements_end (unsigned int level) const override
virtual element_iterator	local_level_elements_begin (unsigned int level) override
virtual element_iterator	local_level_elements_end (unsigned int level) override
virtual const_element_iterator	local_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	local_level_elements_end (unsigned int level) const override
virtual element_iterator	local_not_level_elements_begin (unsigned int level) override
virtual element_iterator	local_not_level_elements_end (unsigned int level) override
virtual const_element_iterator	local_not_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	local_not_level_elements_end (unsigned int level) const override
virtual element_iterator	pid_elements_begin (processor_id_type proc_id) override
virtual element_iterator	pid_elements_end (processor_id_type proc_id) override
virtual const_element_iterator	pid_elements_begin (processor_id_type proc_id) const override
virtual const_element_iterator	pid_elements_end (processor_id_type proc_id) const override
virtual element_iterator	type_elements_begin (ElemType type) override
virtual element_iterator	type_elements_end (ElemType type) override
virtual const_element_iterator	type_elements_begin (ElemType type) const override
virtual const_element_iterator	type_elements_end (ElemType type) const override
virtual element_iterator	active_type_elements_begin (ElemType type) override
virtual element_iterator	active_type_elements_end (ElemType type) override
virtual const_element_iterator	active_type_elements_begin (ElemType type) const override
virtual const_element_iterator	active_type_elements_end (ElemType type) const override
virtual element_iterator	active_pid_elements_begin (processor_id_type proc_id) override
virtual element_iterator	active_pid_elements_end (processor_id_type proc_id) override
virtual const_element_iterator	active_pid_elements_begin (processor_id_type proc_id) const override
virtual const_element_iterator	active_pid_elements_end (processor_id_type proc_id) const override
virtual element_iterator	unpartitioned_elements_begin () override
virtual element_iterator	unpartitioned_elements_end () override
virtual const_element_iterator	unpartitioned_elements_begin () const override
virtual const_element_iterator	unpartitioned_elements_end () const override
virtual element_iterator	active_unpartitioned_elements_begin () override
virtual element_iterator	active_unpartitioned_elements_end () override
virtual const_element_iterator	active_unpartitioned_elements_begin () const override
virtual const_element_iterator	active_unpartitioned_elements_end () const override
virtual element_iterator	active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) override
virtual element_iterator	active_local_subdomain_elements_end (subdomain_id_type subdomain_id) override
virtual const_element_iterator	active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
virtual const_element_iterator	active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const override
virtual element_iterator	active_subdomain_elements_begin (subdomain_id_type subdomain_id) override
virtual element_iterator	active_subdomain_elements_end (subdomain_id_type subdomain_id) override
virtual const_element_iterator	active_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
virtual const_element_iterator	active_subdomain_elements_end (subdomain_id_type subdomain_id) const override
virtual element_iterator	active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) override
virtual element_iterator	active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) override
virtual const_element_iterator	active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) const override
virtual const_element_iterator	active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) const override
virtual element_iterator	ghost_elements_begin () override
virtual element_iterator	ghost_elements_end () override
virtual const_element_iterator	ghost_elements_begin () const override
virtual const_element_iterator	ghost_elements_end () const override
virtual element_iterator	evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual element_iterator	evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual const_element_iterator	evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual const_element_iterator	evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual element_iterator	flagged_elements_begin (unsigned char rflag) override
virtual element_iterator	flagged_elements_end (unsigned char rflag) override
virtual const_element_iterator	flagged_elements_begin (unsigned char rflag) const override
virtual const_element_iterator	flagged_elements_end (unsigned char rflag) const override
virtual element_iterator	flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) override
virtual element_iterator	flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) override
virtual const_element_iterator	flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) const override
virtual const_element_iterator	flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) const override
virtual node_iterator	nodes_begin () override
virtual node_iterator	nodes_end () override
virtual const_node_iterator	nodes_begin () const override
virtual const_node_iterator	nodes_end () const override
virtual SimpleRange< node_iterator >	node_ptr_range () override
virtual SimpleRange< const_node_iterator >	node_ptr_range () const override
virtual node_iterator	active_nodes_begin () override
virtual node_iterator	active_nodes_end () override
virtual const_node_iterator	active_nodes_begin () const override
virtual const_node_iterator	active_nodes_end () const override
virtual node_iterator	local_nodes_begin () override
virtual node_iterator	local_nodes_end () override
virtual const_node_iterator	local_nodes_begin () const override
virtual const_node_iterator	local_nodes_end () const override
virtual SimpleRange< node_iterator >	local_node_ptr_range () override
virtual SimpleRange< const_node_iterator >	local_node_ptr_range () const override
virtual node_iterator	pid_nodes_begin (processor_id_type proc_id) override
virtual node_iterator	pid_nodes_end (processor_id_type proc_id) override
virtual const_node_iterator	pid_nodes_begin (processor_id_type proc_id) const override
virtual const_node_iterator	pid_nodes_end (processor_id_type proc_id) const override
virtual node_iterator	bid_nodes_begin (boundary_id_type bndry_id) override
virtual node_iterator	bid_nodes_end (boundary_id_type bndry_id) override
virtual const_node_iterator	bid_nodes_begin (boundary_id_type bndry_id) const override
virtual const_node_iterator	bid_nodes_end (boundary_id_type bndry_id) const override
virtual node_iterator	bnd_nodes_begin () override
virtual node_iterator	bnd_nodes_end () override
virtual const_node_iterator	bnd_nodes_begin () const override
virtual const_node_iterator	bnd_nodes_end () const override
virtual node_iterator	evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual node_iterator	evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual const_node_iterator	evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual const_node_iterator	evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual void	read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) override
virtual void	write (const std::string &name) override
void	write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names)
virtual void	all_first_order () override
virtual void	all_second_order (const bool full_ordered=true) override
void	create_pid_mesh (UnstructuredMesh &pid_mesh, const processor_id_type pid) const
void	create_submesh (UnstructuredMesh &new_mesh, const const_element_iterator &it, const const_element_iterator &it_end) const
virtual void	copy_nodes_and_elements (const UnstructuredMesh &other_mesh, const bool skip_find_neighbors=false, dof_id_type element_id_offset=0, dof_id_type node_id_offset=0, unique_id_type unique_id_offset=0)
virtual void	find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) override
virtual bool	contract () override
virtual std::unique_ptr< Partitioner > &	partitioner ()
const BoundaryInfo &	get_boundary_info () const
BoundaryInfo &	get_boundary_info ()
bool	is_prepared () const
virtual bool	is_serial () const
virtual bool	is_serial_on_zero () const
virtual void	set_distributed ()
virtual bool	is_replicated () const
virtual void	allgather ()
virtual void	gather_to_zero ()
virtual void	delete_remote_elements ()
unsigned int	mesh_dimension () const
void	set_mesh_dimension (unsigned char d)
const std::set< unsigned char > &	elem_dimensions () const
unsigned int	spatial_dimension () const
void	set_spatial_dimension (unsigned char d)
dof_id_type	n_nodes_on_proc (const processor_id_type proc) const
dof_id_type	n_local_nodes () const
dof_id_type	n_unpartitioned_nodes () const
unique_id_type	next_unique_id ()
void	set_next_unique_id (unique_id_type id)
dof_id_type	n_elem_on_proc (const processor_id_type proc) const
dof_id_type	n_local_elem () const
dof_id_type	n_unpartitioned_elem () const
dof_id_type	n_active_elem_on_proc (const processor_id_type proc) const
dof_id_type	n_active_local_elem () const
dof_id_type	n_sub_elem () const
dof_id_type	n_active_sub_elem () const
virtual const Node &	node_ref (const dof_id_type i) const
virtual Node &	node_ref (const dof_id_type i)
virtual const Node &	node (const dof_id_type i) const
virtual Node &	node (const dof_id_type i)
virtual const Elem &	elem_ref (const dof_id_type i) const
virtual Elem &	elem_ref (const dof_id_type i)
virtual const Elem *	elem (const dof_id_type i) const
virtual Elem *	elem (const dof_id_type i)
virtual const Elem *	query_elem (const dof_id_type i) const
virtual Elem *	query_elem (const dof_id_type i)
virtual void	own_node (Node &)
void	prepare_for_use (const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
virtual void	partition (const unsigned int n_parts)
void	partition ()
virtual void	redistribute ()
virtual void	update_post_partitioning ()
void	allow_renumbering (bool allow)
bool	allow_renumbering () const
void	allow_remote_element_removal (bool allow)
bool	allow_remote_element_removal () const
void	skip_partitioning (bool skip)
bool	skip_partitioning () const
void	add_ghosting_functor (GhostingFunctor &ghosting_functor)
void	remove_ghosting_functor (GhostingFunctor &ghosting_functor)
std::set< GhostingFunctor * >::const_iterator	ghosting_functors_begin () const
std::set< GhostingFunctor * >::const_iterator	ghosting_functors_end () const
GhostingFunctor &	default_ghosting ()
void	subdomain_ids (std::set< subdomain_id_type > &ids) const
subdomain_id_type	n_subdomains () const
unsigned int	n_partitions () const
std::string	get_info () const
void	print_info (std::ostream &os=libMesh::out) const
unsigned int	recalculate_n_partitions ()
const PointLocatorBase &	point_locator () const
std::unique_ptr< PointLocatorBase >	sub_point_locator () const
void	clear_point_locator ()
void	set_count_lower_dim_elems_in_point_locator (bool count_lower_dim_elems)
bool	get_count_lower_dim_elems_in_point_locator () const
virtual void	libmesh_assert_valid_parallel_ids () const
std::string &	subdomain_name (subdomain_id_type id)
const std::string &	subdomain_name (subdomain_id_type id) const
subdomain_id_type	get_id_by_name (const std::string &name) const
std::map< subdomain_id_type, std::string > &	set_subdomain_name_map ()
const std::map< subdomain_id_type, std::string > &	get_subdomain_name_map () const
void	cache_elem_dims ()
void	detect_interior_parents ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Public Attributes
std::unique_ptr< BoundaryInfo >	boundary_info

Protected Member Functions
unsigned int &	set_n_partitions ()

Protected Attributes
std::vector< Node * >	_nodes
std::vector< Elem * >	_elements
unsigned int	_n_parts
bool	_is_prepared
std::unique_ptr< PointLocatorBase >	_point_locator
bool	_count_lower_dim_elems_in_point_locator
std::unique_ptr< Partitioner >	_partitioner
unique_id_type	_next_unique_id
bool	_skip_partitioning
bool	_skip_renumber_nodes_and_elements
bool	_allow_remote_element_removal
std::map< subdomain_id_type, std::string >	_block_id_to_name
std::set< unsigned char >	_elem_dims
unsigned char	_spatial_dimension
std::unique_ptr< GhostingFunctor >	_default_ghosting
std::set< GhostingFunctor * >	_ghosting_functors
const Parallel::Communicator &	_communicator

Private Types
typedef std::vector< Elem * >::iterator	elem_iterator_imp
typedef std::vector< Elem * >::const_iterator	const_elem_iterator_imp
typedef std::vector< Node * >::iterator	node_iterator_imp
typedef std::vector< Node * >::const_iterator	const_node_iterator_imp

Private Member Functions
void	stitching_helper (const ReplicatedMesh *other_mesh, boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol, bool clear_stitched_boundary_ids, bool verbose, bool use_binary_search, bool enforce_all_nodes_match_on_boundaries, bool skip_find_neighbors)

Detailed Description

Mesh data structure replicated on all processors.

The ReplicatedMesh class is derived from the MeshBase class, and is used to store identical copies of a full mesh data structure on each processor.

Most methods for this class are found in MeshBase, and most implementation details are found in UnstructuredMesh.

Author

Roy Stogner

Date

2007

Definition at line 46 of file replicated_mesh.h.

Member Typedef Documentation

const_elem_iterator_imp

typedef std::vector<Elem *>::const_iterator libMesh::ReplicatedMesh::const_elem_iterator_imp

private

Definition at line 497 of file replicated_mesh.h.

const_node_iterator_imp

typedef std::vector<Node *>::const_iterator libMesh::ReplicatedMesh::const_node_iterator_imp

private

Definition at line 504 of file replicated_mesh.h.

elem_iterator_imp

typedef std::vector<Elem *>::iterator libMesh::ReplicatedMesh::elem_iterator_imp

private

Typedefs for the container implementation. In this case, it's just a std::vector<Elem *>.

Definition at line 496 of file replicated_mesh.h.

node_iterator_imp

typedef std::vector<Node *>::iterator libMesh::ReplicatedMesh::node_iterator_imp

private

Typedefs for the container implementation. In this case, it's just a std::vector<Node *>.

Definition at line 503 of file replicated_mesh.h.

Predicate

typedef Predicates::multi_predicate libMesh::MeshBase::Predicate

inherited

We need an empty, generic class to act as a predicate for this and derived mesh classes.

Definition at line 931 of file mesh_base.h.

Constructor & Destructor Documentation

ReplicatedMesh() [1/4]

libMesh::ReplicatedMesh::ReplicatedMesh ( const Parallel::Communicator &  comm_in, unsigned char  dim = 1  )

explicit

Constructor. Takes dim, the dimension of the mesh. The mesh dimension can be changed (and may automatically be changed by mesh generation/loading) later.

Definition at line 119 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, and libMesh::MeshBase::_partitioner.

                                                 :
  UnstructuredMesh (comm_in,d)
{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // In serial we just need to reset the next unique id to zero
  // here in the constructor.
  _next_unique_id = 0;
#endif
  _partitioner = libmesh_make_unique<MetisPartitioner>();
}

ReplicatedMesh() [2/4]

libMesh::ReplicatedMesh::ReplicatedMesh

(

const UnstructuredMesh &

other_mesh

)

Copy-constructor. This should be able to take a serial or parallel mesh.

Definition at line 153 of file replicated_mesh.C.

References libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::MeshBase::get_boundary_info().

                                                                   :
  UnstructuredMesh (other_mesh)
{
  this->copy_nodes_and_elements(other_mesh);
  this->get_boundary_info() = other_mesh.get_boundary_info();
}

ReplicatedMesh() [3/4]

libMesh::ReplicatedMesh::ReplicatedMesh

(

const ReplicatedMesh &

other_mesh

)

Copy-constructor, possibly specialized for a serial mesh.

Definition at line 142 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::MeshBase::get_boundary_info().

                                                                 :
  UnstructuredMesh (other_mesh)
{
  this->copy_nodes_and_elements(other_mesh);
  this->get_boundary_info() = other_mesh.get_boundary_info();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  this->_next_unique_id = other_mesh._next_unique_id;
#endif
}

ReplicatedMesh() [4/4]

libMesh::ReplicatedMesh::ReplicatedMesh ( ReplicatedMesh &&  )

default

Move-constructor.

~ReplicatedMesh()

libMesh::ReplicatedMesh::~ReplicatedMesh ( )

virtual

Destructor.

Definition at line 133 of file replicated_mesh.C.

References clear().

{
  this->clear();  // Free nodes and elements
}

Member Function Documentation

active_element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::ReplicatedMesh::active_element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 246 of file replicated_mesh.h.

References active_elements_begin(), and active_elements_end().

{ return {active_elements_begin(), active_elements_end()}; }

active_element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::ReplicatedMesh::active_element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 247 of file replicated_mesh.h.

References active_elements_begin(), and active_elements_end().

{ return {active_elements_begin(), active_elements_end()}; }

active_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_elements_begin ( )

overridevirtual

Active, local, and negation forms of the element iterators described above. An "active" element is an element without children (i.e. has not been refined). A "local" element is one whose processor_id() matches the current processor.

Implements libMesh::MeshBase.

Referenced by active_element_ptr_range(), n_active_elem(), and stitching_helper().

active_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_element_ptr_range(), and n_active_elem().

active_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::ReplicatedMesh::active_local_element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 303 of file replicated_mesh.h.

References active_local_elements_begin(), and active_local_elements_end().

{ return {active_local_elements_begin(), active_local_elements_end()}; }

active_local_element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::ReplicatedMesh::active_local_element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 304 of file replicated_mesh.h.

References active_local_elements_begin(), and active_local_elements_end().

{ return {active_local_elements_begin(), active_local_elements_end()}; }

active_local_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_element_ptr_range().

active_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_element_ptr_range().

active_local_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::active_nodes_begin ( )

overridevirtual

Iterate over only the active nodes in the Mesh.

Implements libMesh::MeshBase.

active_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::active_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::active_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::active_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_not_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_not_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_not_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_not_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_pid_elements_begin ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_pid_elements_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_pid_elements_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_pid_elements_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_semilocal_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_semilocal_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_semilocal_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_semilocal_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type >  ss )

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type >  ss ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type >  ss )

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type >  ss ) const

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_type_elements_begin ( ElemType  type )

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_type_elements_begin ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_type_elements_end ( ElemType  type )

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_type_elements_end ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_unpartitioned_elements_begin ( )

overridevirtual

Iterate over active unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

active_unpartitioned_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_unpartitioned_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::active_unpartitioned_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::active_unpartitioned_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

add_elem()

Elem * libMesh::ReplicatedMesh::add_elem ( Elem *  e )

overridevirtual

Add elem e to the end of the element array. To add an element locally, set e->processor_id() before adding it. To ensure a specific element id, call e->set_id() before adding it; only do this in parallel if you are manually keeping ids consistent.

Users should call MeshBase::prepare_for_use() after elements are added to and/or deleted from the mesh.

Implements libMesh::MeshBase.

Definition at line 269 of file replicated_mesh.C.

References _elements, libMesh::MeshBase::_next_unique_id, libMesh::DofObject::id(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

{
  libmesh_assert(e);

  // We no longer merely append elements with ReplicatedMesh

  // If the user requests a valid id that doesn't correspond to an
  // existing element, let's give them that id, resizing the elements
  // container if necessary.
  if (!e->valid_id())
    e->set_id (cast_int<dof_id_type>(_elements.size()));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    e->set_unique_id() = _next_unique_id++;
#endif

  const dof_id_type id = e->id();

  if (id < _elements.size())
    {
      // Overwriting existing elements is still probably a mistake.
      libmesh_assert(!_elements[id]);
    }
  else
    {
      _elements.resize(id+1, nullptr);
    }

  _elements[id] = e;

  return e;
}

add_ghosting_functor()

void libMesh::MeshBase::add_ghosting_functor ( GhostingFunctor &  ghosting_functor )

inlineinherited

Adds a functor which can specify ghosting requirements for use on distributed meshes. Multiple ghosting functors can be added; any element which is required by any functor will be ghosted.

GhostingFunctor memory must be managed by the code which calls this function; the GhostingFunctor lifetime is expected to extend until either the functor is removed or the Mesh is destructed.

Definition at line 823 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::DofMap::add_algebraic_ghosting_functor(), and libMesh::DofMap::add_coupling_functor().

  { _ghosting_functors.insert(&ghosting_functor); }

add_node()

Node * libMesh::ReplicatedMesh::add_node ( Node *  n )

overridevirtual

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 439 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, _nodes, libMesh::DofObject::id(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

{
  libmesh_assert(n);
  // We only append points with ReplicatedMesh
  libmesh_assert(!n->valid_id() || n->id() == _nodes.size());

  n->set_id (cast_int<dof_id_type>(_nodes.size()));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!n->valid_unique_id())
    n->set_unique_id() = _next_unique_id++;
#endif

  _nodes.push_back(n);

  return n;
}

add_point()

Node * libMesh::ReplicatedMesh::add_point ( const Point &  p, const dof_id_type  id = DofObject::invalid_id, const processor_id_type  proc_id = DofObject::invalid_processor_id  )

overridevirtual

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 386 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, _nodes, libMesh::Node::build(), libMesh::DofObject::invalid_id, libMesh::DofObject::processor_id(), libMesh::DofObject::set_unique_id(), and libMesh::DofObject::valid_unique_id().

{
  //   // We only append points with ReplicatedMesh
  //   libmesh_assert(id == DofObject::invalid_id || id == _nodes.size());
  //   Node *n = Node::build(p, _nodes.size()).release();
  //   n->processor_id() = proc_id;
  //   _nodes.push_back (n);

  Node * n = nullptr;

  // If the user requests a valid id, either
  // provide the existing node or resize the container
  // to fit the new node.
  if (id != DofObject::invalid_id)
    if (id < _nodes.size())
      n = _nodes[id];
    else
      _nodes.resize(id+1);
  else
    _nodes.push_back (static_cast<Node *>(nullptr));

  // if the node already exists, then assign new (x,y,z) values
  if (n)
    *n = p;
  // otherwise build a new node, put it in the right spot, and return
  // a valid pointer.
  else
    {
      n = Node::build(p, (id == DofObject::invalid_id) ?
                      cast_int<dof_id_type>(_nodes.size()-1) : id).release();
      n->processor_id() = proc_id;

#ifdef LIBMESH_ENABLE_UNIQUE_ID
      if (!n->valid_unique_id())
        n->set_unique_id() = _next_unique_id++;
#endif

      if (id == DofObject::invalid_id)
        _nodes.back() = n;
      else
        _nodes[id] = n;
    }

  // better not pass back a nullptr.
  libmesh_assert (n);

  return n;
}

all_first_order()

void libMesh::UnstructuredMesh::all_first_order ( )

overridevirtualinherited

Converts a mesh with higher-order elements into a mesh with linear elements. For example, a mesh consisting of Tet10 will be converted to a mesh with Tet4 etc.

Prepare to identify (and then delete) a bunch of no-longer-used nodes.

If the second order element had any boundary conditions they should be transferred to the first-order element. The old boundary conditions will be removed from the BoundaryInfo data structure by insert_elem.

Implements libMesh::MeshBase.

Definition at line 832 of file unstructured_mesh.C.

References libMesh::MeshBase::_is_prepared, libMesh::Elem::add_child(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::MeshBase::delete_node(), libMesh::MeshBase::element_ptr_range(), libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::MeshBase::max_node_id(), libMesh::Elem::n_vertices(), libMesh::MeshBase::node(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr_range(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::remote_elem, libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::Elem::replace_child(), libMesh::DofObject::set_id(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_node(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_parent(), libMesh::Elem::set_refinement_flag(), libMesh::DofObject::set_unique_id(), and libMesh::Elem::subdomain_id().

{
  /*
   * when the mesh is not prepared,
   * at least renumber the nodes and
   * elements, so that the node ids
   * are correct
   */
  if (!this->_is_prepared)
    this->renumber_nodes_and_elements ();

  START_LOG("all_first_order()", "Mesh");

  std::vector<bool> node_touched_by_me(this->max_node_id(), false);

  // Loop over the high-ordered elements.
  // First make sure they _are_ indeed high-order, and then replace
  // them with an equivalent first-order element.
  for (auto & so_elem : element_ptr_range())
    {
      libmesh_assert(so_elem);

      /*
       * build the first-order equivalent, add to
       * the new_elements list.
       */
      Elem * lo_elem = Elem::build
        (Elem::first_order_equivalent_type
         (so_elem->type()), so_elem->parent()).release();

      const unsigned short n_sides = so_elem->n_sides();

      for (unsigned short s=0; s != n_sides; ++s)
        if (so_elem->neighbor_ptr(s) == remote_elem)
          lo_elem->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));

#ifdef LIBMESH_ENABLE_AMR
      /*
       * Reset the parent links of any child elements
       */
      if (so_elem->has_children())
        for (unsigned int c = 0, nc = so_elem->n_children(); c != nc; ++c)
          {
            Elem * child = so_elem->child_ptr(c);
            child->set_parent(lo_elem);
            lo_elem->add_child(child, c);
          }

      /*
       * Reset the child link of any parent element
       */
      if (so_elem->parent())
        {
          unsigned int c =
            so_elem->parent()->which_child_am_i(so_elem);
          lo_elem->parent()->replace_child(lo_elem, c);
        }

      /*
       * Copy as much data to the new element as makes sense
       */
      lo_elem->set_p_level(so_elem->p_level());
      lo_elem->set_refinement_flag(so_elem->refinement_flag());
      lo_elem->set_p_refinement_flag(so_elem->p_refinement_flag());
#endif

      libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());

      /*
       * By definition the vertices of the linear and
       * second order element are identically numbered.
       * transfer these.
       */
      for (unsigned int v=0; v < so_elem->n_vertices(); v++)
        {
          lo_elem->set_node(v) = so_elem->node_ptr(v);
          node_touched_by_me[lo_elem->node_id(v)] = true;
        }

      /*
       * find_neighbors relies on remote_elem neighbor links being
       * properly maintained.
       */
      for (unsigned short s=0; s != n_sides; s++)
        {
          if (so_elem->neighbor_ptr(s) == remote_elem)
            lo_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
        }

      this->get_boundary_info().copy_boundary_ids
        (this->get_boundary_info(), so_elem, lo_elem);

      /*
       * The new first-order element is ready.
       * Inserting it into the mesh will replace and delete
       * the second-order element.
       */
      lo_elem->set_id(so_elem->id());
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      lo_elem->set_unique_id() = so_elem->unique_id();
#endif
      lo_elem->processor_id() = so_elem->processor_id();
      lo_elem->subdomain_id() = so_elem->subdomain_id();
      this->insert_elem(lo_elem);
    }

  // Deleting nodes does not invalidate iterators, so this is safe.
  for (const auto & node : this->node_ptr_range())
    if (!node_touched_by_me[node->id()])
      this->delete_node(node);

  // If crazy people applied boundary info to non-vertices and then
  // deleted those non-vertices, we should make sure their boundary id
  // caches are correct.
  this->get_boundary_info().regenerate_id_sets();

  STOP_LOG("all_first_order()", "Mesh");

  // On hanging nodes that used to also be second order nodes, we
  // might now have an invalid nodal processor_id()
  Partitioner::set_node_processor_ids(*this);

  // delete or renumber nodes if desired
  this->prepare_for_use();
}

all_second_order()

void libMesh::UnstructuredMesh::all_second_order ( const bool  full_ordered = true )

overridevirtualinherited

Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements. For example, a mesh consisting of Tet4 will be converted to a mesh with Tet10 etc.

Note

For some elements like Hex8 there exist two higher order equivalents, Hex20 and Hex27. When full_ordered is true (default), then Hex27 is built. Otherwise, Hex20 is built. The same holds obviously for Quad4, Prism6, etc.

Loop over the low-ordered elements in the elements vector. First make sure they _are indeed low-order, and then replace them with an equivalent second-order element. Don't forget to delete the low-order element, or else it will leak!

If the linear element had any boundary conditions they should be transferred to the second-order element. The old boundary conditions will be removed from the BoundaryInfo data structure by insert_elem.

Also, prepare_for_use() will reconstruct most of our neighbor links, but if we have any remote_elem links in a distributed mesh, they need to be preserved. We do that in the same loop here.

Implements libMesh::MeshBase.

Definition at line 969 of file unstructured_mesh.C.

References libMesh::MeshBase::_is_prepared, libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::Elem::default_order(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::FIRST, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::DofObject::invalid_id, libMesh::MeshBase::is_replicated(), libMesh::MeshBase::is_serial(), libMesh::Elem::level(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::mesh_dimension(), std::min(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::MeshBase::own_node(), libMesh::MeshBase::point(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::remote_elem, libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::second_order_equivalent_type(), libMesh::Elem::side_index_range(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::DofObject::unique_id().

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

  /*
   * when the mesh is not prepared,
   * at least renumber the nodes and
   * elements, so that the node ids
   * are correct
   */
  if (!this->_is_prepared)
    this->renumber_nodes_and_elements ();

  /*
   * If the mesh is empty
   * then we have nothing to do
   */
  if (!this->n_elem())
    return;

  /*
   * If the mesh is already second order
   * then we have nothing to do.
   * We have to test for this in a round-about way to avoid
   * a bug on distributed parallel meshes with more processors
   * than elements.
   */
  bool already_second_order = false;
  if (this->elements_begin() != this->elements_end() &&
      (*(this->elements_begin()))->default_order() != FIRST)
    already_second_order = true;
  this->comm().max(already_second_order);
  if (already_second_order)
    return;

  START_LOG("all_second_order()", "Mesh");

  /*
   * this map helps in identifying second order
   * nodes.  Namely, a second-order node:
   * - edge node
   * - face node
   * - bubble node
   * is uniquely defined through a set of adjacent
   * vertices.  This set of adjacent vertices is
   * used to identify already added higher-order
   * nodes.  We are safe to use node id's since we
   * make sure that these are correctly numbered.
   */
  std::map<std::vector<dof_id_type>, Node *> adj_vertices_to_so_nodes;

  /*
   * for speed-up of the \p add_point() method, we
   * can reserve memory.  Guess the number of additional
   * nodes for different dimensions
   */
  switch (this->mesh_dimension())
    {
    case 1:
      /*
       * in 1D, there can only be order-increase from Edge2
       * to Edge3.  Something like 1/2 of n_nodes() have
       * to be added
       */
      this->reserve_nodes(static_cast<unsigned int>
                          (1.5*static_cast<double>(this->n_nodes())));
      break;

    case 2:
      /*
       * in 2D, either refine from Tri3 to Tri6 (double the nodes)
       * or from Quad4 to Quad8 (again, double) or Quad9 (2.25 that much)
       */
      this->reserve_nodes(static_cast<unsigned int>
                          (2*static_cast<double>(this->n_nodes())));
      break;


    case 3:
      /*
       * in 3D, either refine from Tet4 to Tet10 (factor = 2.5) up to
       * Hex8 to Hex27 (something  > 3).  Since in 3D there _are_ already
       * quite some nodes, and since we do not want to overburden the memory by
       * a too conservative guess, use the lower bound
       */
      this->reserve_nodes(static_cast<unsigned int>
                          (2.5*static_cast<double>(this->n_nodes())));
      break;

    default:
      // Hm?
      libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
    }



  /*
   * form a vector that will hold the node id's of
   * the vertices that are adjacent to the son-th
   * second-order node.  Pull this outside of the
   * loop so that silly compilers don't repeatedly
   * create and destroy the vector.
   */
  std::vector<dof_id_type> adjacent_vertices_ids;

  element_iterator
    it = elements_begin(),
    endit = elements_end();

  for (; it != endit; ++it)
    {
      // the linear-order element
      Elem * lo_elem = *it;

      libmesh_assert(lo_elem);

      // make sure it is linear order
      if (lo_elem->default_order() != FIRST)
        libmesh_error_msg("ERROR: This is not a linear element: type=" << lo_elem->type());

      // this does _not_ work for refined elements
      libmesh_assert_equal_to (lo_elem->level (), 0);

      /*
       * build the second-order equivalent, add to
       * the new_elements list.  Note that this here
       * is the only point where \p full_ordered
       * is necessary.  The remaining code works well
       * for either type of second-order equivalent, e.g.
       * Hex20 or Hex27, as equivalents for Hex8
       */
      Elem * so_elem =
        Elem::build (Elem::second_order_equivalent_type(lo_elem->type(),
                                                        full_ordered) ).release();

      libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());


      /*
       * By definition the vertices of the linear and
       * second order element are identically numbered.
       * transfer these.
       */
      for (unsigned int v=0; v < lo_elem->n_vertices(); v++)
        so_elem->set_node(v) = lo_elem->node_ptr(v);

      /*
       * Now handle the additional mid-side nodes.  This
       * is simply handled through a map that remembers
       * the already-added nodes.  This map maps the global
       * ids of the vertices (that uniquely define this
       * higher-order node) to the new node.
       * Notation: son = second-order node
       */
      const unsigned int son_begin = so_elem->n_vertices();
      const unsigned int son_end   = so_elem->n_nodes();


      for (unsigned int son=son_begin; son<son_end; son++)
        {
          const unsigned int n_adjacent_vertices =
            so_elem->n_second_order_adjacent_vertices(son);

          adjacent_vertices_ids.resize(n_adjacent_vertices);

          for (unsigned int v=0; v<n_adjacent_vertices; v++)
            adjacent_vertices_ids[v] =
              so_elem->node_id( so_elem->second_order_adjacent_vertex(son,v) );

          /*
           * \p adjacent_vertices_ids is now in order of the current
           * side.  sort it, so that comparisons  with the
           * \p adjacent_vertices_ids created through other elements'
           * sides can match
           */
          std::sort(adjacent_vertices_ids.begin(),
                    adjacent_vertices_ids.end());


          // does this set of vertices already have a mid-node added?
          auto pos = adj_vertices_to_so_nodes.equal_range (adjacent_vertices_ids);

          // no, not added yet
          if (pos.first == pos.second)
            {
              /*
               * for this set of vertices, there is no
               * second_order node yet.  Add it.
               *
               * compute the location of the new node as
               * the average over the adjacent vertices.
               */
              Point new_location = this->point(adjacent_vertices_ids[0]);
              for (unsigned int v=1; v<n_adjacent_vertices; v++)
                new_location += this->point(adjacent_vertices_ids[v]);

              new_location /= static_cast<Real>(n_adjacent_vertices);

              /* Add the new point to the mesh.
               * If we are on a serialized mesh, then we're doing this
               * all in sync, and the node processor_id will be
               * consistent between processors.
               * If we are on a distributed mesh, we can fix
               * inconsistent processor ids later, but only if every
               * processor gives new nodes a *locally* consistent
               * processor id, so we'll give the new node the
               * processor id of an adjacent element for now and then
               * we'll update that later if appropriate.
               */
              Node * so_node = this->add_point
                (new_location, DofObject::invalid_id,
                 lo_elem->processor_id());

              /*
               * insert the new node with its defining vertex
               * set into the map, and relocate pos to this
               * new entry, so that the so_elem can use
               * \p pos for inserting the node
               */
              adj_vertices_to_so_nodes.insert(pos.first,
                                              std::make_pair(adjacent_vertices_ids,
                                                             so_node));

              so_elem->set_node(son) = so_node;
            }
          // yes, already added.
          else
            {
              Node * so_node = pos.first->second;
              libmesh_assert(so_node);

              so_elem->set_node(son) = so_node;

              // We need to ensure that the processor who should own a
              // node *knows* they own the node.  And because
              // Node::choose_processor_id() may depend on Node id,
              // which may not yet be authoritative, we still have to
              // use a dumb-but-id-independent partitioning heuristic.
              processor_id_type chosen_pid =
                std::min (so_node->processor_id(),
                          lo_elem->processor_id());

              // Plus, if we just discovered that we own this node,
              // then on a distributed mesh we need to make sure to
              // give it a valid id, not just a placeholder id!
              if (!this->is_replicated() &&
                  so_node->processor_id() != this->processor_id() &&
                  chosen_pid == this->processor_id())
                this->own_node(*so_node);

              so_node->processor_id() = chosen_pid;
            }
        }

      /*
       * find_neighbors relies on remote_elem neighbor links being
       * properly maintained.
       */
      for (auto s : lo_elem->side_index_range())
        {
          if (lo_elem->neighbor_ptr(s) == remote_elem)
            so_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
        }

      this->get_boundary_info().copy_boundary_ids
        (this->get_boundary_info(), lo_elem, so_elem);

      /*
       * The new second-order element is ready.
       * Inserting it into the mesh will replace and delete
       * the first-order element.
       */
      so_elem->set_id(lo_elem->id());
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      so_elem->set_unique_id() = lo_elem->unique_id();
#endif
      so_elem->processor_id() = lo_elem->processor_id();
      so_elem->subdomain_id() = lo_elem->subdomain_id();
      this->insert_elem(so_elem);
    }

  // we can clear the map
  adj_vertices_to_so_nodes.clear();


  STOP_LOG("all_second_order()", "Mesh");

  // On a DistributedMesh our ghost node processor ids may be bad,
  // the ids of nodes touching remote elements may be inconsistent,
  // unique_ids of newly added non-local nodes remain unset, and our
  // partitioning of new nodes may not be well balanced.
  //
  // make_nodes_parallel_consistent() will fix all this.
  if (!this->is_serial())
    MeshCommunication().make_nodes_parallel_consistent (*this);

  // renumber nodes, elements etc
  this->prepare_for_use(/*skip_renumber =*/ false);
}

allgather()

virtual void libMesh::MeshBase::allgather ( )

inlinevirtualinherited

Gathers all elements and nodes of the mesh onto every processor

Reimplemented in libMesh::DistributedMesh.

Definition at line 183 of file mesh_base.h.

Referenced by libMesh::EquationSystems::allgather(), and libMesh::MeshSerializer::MeshSerializer().

{}

allow_remote_element_removal() [1/2]

void libMesh::MeshBase::allow_remote_element_removal ( bool  allow )

inlineinherited

If false is passed in then this mesh will no longer have remote elements deleted when being prepared for use; i.e. even a DistributedMesh will remain (if it is already) serialized. This may adversely affect performance and memory use.

Definition at line 791 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

{ _allow_remote_element_removal = allow; }

allow_remote_element_removal() [2/2]

bool libMesh::MeshBase::allow_remote_element_removal ( ) const

inlineinherited

Definition at line 792 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

{ return _allow_remote_element_removal; }

allow_renumbering() [1/2]

void libMesh::MeshBase::allow_renumbering ( bool  allow )

inlineinherited

If false is passed in then this mesh will no longer be renumbered when being prepared for use. This may slightly adversely affect performance during subsequent element access, particularly when using a distributed mesh.

Important! When allow_renumbering(false) is set, ReplicatedMesh::n_elem() and ReplicatedMesh::n_nodes() will return wrong values whenever adaptive refinement is followed by adaptive coarsening. (Uniform refinement followed by uniform coarsening is OK.) This is due to the fact that n_elem() and n_nodes() are currently O(1) functions that just return the size of the respective underlying vectors, and this size is wrong when the numbering includes "gaps" from nodes and elements that have been deleted. We plan to implement a caching mechanism in the near future that will fix this incorrect behavior.

Definition at line 782 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::NameBasedIO::read(), and libMesh::GMVIO::read().

{ _skip_renumber_nodes_and_elements = !allow; }

allow_renumbering() [2/2]

bool libMesh::MeshBase::allow_renumbering ( ) const

inlineinherited

Definition at line 783 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::prepare_for_use(), and libMesh::UnstructuredMesh::read().

{ return !_skip_renumber_nodes_and_elements; }

ancestor_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::ancestor_elements_begin ( )

overridevirtual

Iterate over elements for which elem->ancestor() is true.

Implements libMesh::MeshBase.

ancestor_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::ancestor_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

ancestor_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::ancestor_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

ancestor_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::ancestor_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::bid_nodes_begin ( boundary_id_type  bndry_id )

overridevirtual

Iterate over nodes for which BoundaryInfo::has_boundary_id(node, bndry_id) is true.

Implements libMesh::MeshBase.

bid_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::bid_nodes_begin ( boundary_id_type  bndry_id ) const

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::bid_nodes_end ( boundary_id_type  bndry_id )

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::bid_nodes_end ( boundary_id_type  bndry_id ) const

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::bnd_nodes_begin ( )

overridevirtual

Iterate over nodes for which BoundaryInfo::n_boundary_ids(node) > 0.

Implements libMesh::MeshBase.

bnd_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::bnd_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::bnd_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::bnd_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )

inherited

Search the mesh and cache the different dimensions of the elements present in the mesh. This is done in prepare_for_use(), but can be done manually by other classes after major mesh modifications.

Definition at line 574 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_spatial_dimension, libMesh::MeshBase::active_element_ptr_range(), libMesh::ParallelObject::comm(), libMesh::Elem::dim(), libMesh::MeshBase::elem(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::node(), libMesh::MeshBase::node_ptr_range(), and libMesh::Parallel::Communicator::set_union().

Referenced by libMesh::MeshBase::prepare_for_use().

{
  // This requires an inspection on every processor
  parallel_object_only();

  // Need to clear _elem_dims first in case all elements of a
  // particular dimension have been deleted.
  _elem_dims.clear();

  for (const auto & elem : this->active_element_ptr_range())
    _elem_dims.insert(cast_int<unsigned char>(elem->dim()));

  // Some different dimension elements may only live on other processors
  this->comm().set_union(_elem_dims);

  // If the largest element dimension found is larger than the current
  // _spatial_dimension, increase _spatial_dimension.
  unsigned int max_dim = this->mesh_dimension();
  if (max_dim > _spatial_dimension)
    _spatial_dimension = cast_int<unsigned char>(max_dim);

  // _spatial_dimension may need to increase from 1->2 or 2->3 if the
  // mesh is full of 1D elements but they are not x-aligned, or the
  // mesh is full of 2D elements but they are not in the x-y plane.
  // If the mesh is x-aligned or x-y planar, we will end up checking
  // every node's coordinates and not breaking out of the loop
  // early...
  if (_spatial_dimension < 3)
    {
      for (const auto & node : this->node_ptr_range())
        {
#if LIBMESH_DIM > 1
          // Note: the exact floating point comparison is intentional,
          // we don't want to get tripped up by tolerances.
          if ((*node)(1) != 0.)
            {
              _spatial_dimension = 2;
#if LIBMESH_DIM == 2
              // If libmesh is compiled in 2D mode, this is the
              // largest spatial dimension possible so we can break
              // out.
              break;
#endif
            }
#endif

#if LIBMESH_DIM > 2
          if ((*node)(2) != 0.)
            {
              // Spatial dimension can't get any higher than this, so
              // we can break out.
              _spatial_dimension = 3;
              break;
            }
#endif
        }
    }
}

clear()

void libMesh::ReplicatedMesh::clear ( )

overridevirtual

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 556 of file replicated_mesh.C.

References _elements, _nodes, libMesh::MeshBase::clear(), libMesh::MeshBase::elem(), and libMesh::MeshBase::node().

Referenced by ~ReplicatedMesh().

{
  // Call parent clear function
  MeshBase::clear();

  // Clear our elements and nodes
  // There is no need to remove the elements from
  // the BoundaryInfo data structure since we
  // already cleared it.
  for (auto & elem : _elements)
    delete elem;

  _elements.clear();

  // clear the nodes data structure
  // There is no need to remove the nodes from
  // the BoundaryInfo data structure since we
  // already cleared it.
  for (auto & node : _nodes)
    delete node;

  _nodes.clear();
}

clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )

inherited

Releases the current PointLocator object.

Definition at line 517 of file mesh_base.C.

References libMesh::MeshBase::_point_locator.

Referenced by libMesh::MeshBase::clear(), libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), and libMesh::MeshBase::prepare_for_use().

{
  _point_locator.reset(nullptr);
}

clone()

virtual std::unique_ptr<MeshBase> libMesh::ReplicatedMesh::clone ( ) const

inlineoverridevirtual

Virtual copy-constructor, creates a copy of this mesh

Implements libMesh::MeshBase.

Reimplemented in libMesh::SerialMesh.

Definition at line 85 of file replicated_mesh.h.

  { return libmesh_make_unique<ReplicatedMesh>(*this); }

comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::PetscDMWrapper::check_section_n_dofs(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

  { return _communicator; }

contract()

bool libMesh::UnstructuredMesh::contract ( )

overridevirtualinherited

Delete subactive (i.e. children of coarsened) elements. This removes all elements descended from currently active elements in the mesh.

Implements libMesh::MeshBase.

Definition at line 769 of file unstructured_mesh.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::as_range(), libMesh::MeshBase::clear_point_locator(), libMesh::Elem::contract(), libMesh::MeshBase::delete_elem(), libMesh::MeshBase::elem(), libMesh::MeshBase::element_ptr_range(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::Elem::parent(), libMesh::MeshBase::renumber_nodes_and_elements(), and libMesh::Elem::subactive().

{
  LOG_SCOPE ("contract()", "Mesh");

  // Flag indicating if this call actually changes the mesh
  bool mesh_changed = false;

#ifdef DEBUG
  for (const auto & elem : this->element_ptr_range())
    libmesh_assert(elem->active() || elem->subactive() || elem->ancestor());
#endif

  // Loop over the elements.
  for (auto & elem : this->element_ptr_range())
    {
      // Delete all the subactive ones
      if (elem->subactive())
        {
          // No level-0 element should be subactive.
          // Note that we CAN'T test elem->level(), as that
          // touches elem->parent()->dim(), and elem->parent()
          // might have already been deleted!
          libmesh_assert(elem->parent());

          // Delete the element
          // This just sets a pointer to nullptr, and doesn't
          // invalidate any iterators
          this->delete_elem(elem);

          // the mesh has certainly changed
          mesh_changed = true;
        }
      else
        {
          // Compress all the active ones
          if (elem->active())
            elem->contract();
          else
            libmesh_assert (elem->ancestor());
        }
    }

  // Strip any newly-created nullptr voids out of the element array
  this->renumber_nodes_and_elements();

  // FIXME: Need to understand why deleting subactive children
  // invalidates the point locator.  For now we will clear it explicitly
  this->clear_point_locator();

  // Allow our GhostingFunctor objects to reinit if necessary.
  for (auto & gf : as_range(this->ghosting_functors_begin(),
                            this->ghosting_functors_end()))
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }

  return mesh_changed;
}

copy_nodes_and_elements()

void libMesh::UnstructuredMesh::copy_nodes_and_elements ( const UnstructuredMesh &  other_mesh, const bool  skip_find_neighbors = false, dof_id_type  element_id_offset = 0, dof_id_type  node_id_offset = 0, unique_id_type  unique_id_offset = 0  )

virtualinherited

Deep copy of another unstructured mesh class (used by subclass copy constructors)

Definition at line 61 of file unstructured_mesh.C.

References libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_n_parts, libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::Elem::build(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::element_ptr_range(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::node_ptr_range(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_neighbor(), libMesh::DofObject::set_unique_id(), libMesh::MeshBase::skip_partitioning(), and libMesh::Elem::subdomain_id().

Referenced by libMesh::DistributedMesh::DistributedMesh(), ReplicatedMesh(), and stitching_helper().

{
  LOG_SCOPE("copy_nodes_and_elements()", "UnstructuredMesh");

  // If we are partitioned into fewer parts than the incoming mesh,
  // then we need to "wrap" the other Mesh's processor ids to fit
  // within our range. This can happen, for example, while stitching
  // ReplicatedMeshes with small numbers of elements in parallel...
  bool wrap_proc_ids = (_n_parts < other_mesh._n_parts);

  // We're assuming our subclass data needs no copy
  libmesh_assert_equal_to (_is_prepared, other_mesh._is_prepared);

  // We're assuming the other mesh has proper element number ordering,
  // so that we add parents before their children, and that the other
  // mesh is consistently partitioned.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_amr_elem_ids(other_mesh);
  MeshTools::libmesh_assert_valid_procids<Node>(other_mesh);
#endif

  //Copy in Nodes
  {
    //Preallocate Memory if necessary
    this->reserve_nodes(other_mesh.n_nodes());

    for (const auto & oldn : other_mesh.node_ptr_range())
      {
        processor_id_type added_pid = cast_int<processor_id_type>
          (wrap_proc_ids ? oldn->processor_id() % _n_parts : oldn->processor_id());

        // Add new nodes in old node Point locations
#ifdef LIBMESH_ENABLE_UNIQUE_ID
        Node * newn =
#endif
          this->add_point(*oldn,
                          oldn->id() + node_id_offset,
                          added_pid);

#ifdef LIBMESH_ENABLE_UNIQUE_ID
        newn->set_unique_id() =
          oldn->unique_id() + unique_id_offset;
#endif
      }
  }

  //Copy in Elements
  {
    //Preallocate Memory if necessary
    this->reserve_elem(other_mesh.n_elem());

    // Declare a map linking old and new elements, needed to copy the neighbor lists
    typedef std::unordered_map<const Elem *, Elem *> map_type;
    map_type old_elems_to_new_elems;

    // Loop over the elements
    for (const auto & old : other_mesh.element_ptr_range())
      {
        // Build a new element
        Elem * newparent = old->parent() ?
          this->elem_ptr(old->parent()->id() + element_id_offset) :
          nullptr;
        std::unique_ptr<Elem> ap = Elem::build(old->type(), newparent);
        Elem * el = ap.release();

        el->subdomain_id() = old->subdomain_id();

        for (auto s : old->side_index_range())
          if (old->neighbor_ptr(s) == remote_elem)
            el->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));

#ifdef LIBMESH_ENABLE_AMR
        if (old->has_children())
          for (unsigned int c = 0, nc = old->n_children(); c != nc; ++c)
            if (old->child_ptr(c) == remote_elem)
              el->add_child(const_cast<RemoteElem *>(remote_elem), c);

        //Create the parent's child pointers if necessary
        if (newparent)
          {
            unsigned int oldc = old->parent()->which_child_am_i(old);
            newparent->add_child(el, oldc);
          }

        // Copy the refinement flags
        el->set_refinement_flag(old->refinement_flag());

        // Use hack_p_level since we may not have sibling elements
        // added yet
        el->hack_p_level(old->p_level());

        el->set_p_refinement_flag(old->p_refinement_flag());
#endif // #ifdef LIBMESH_ENABLE_AMR

        //Assign all the nodes
        for (auto i : el->node_index_range())
          el->set_node(i) =
            this->node_ptr(old->node_id(i) + node_id_offset);

        // And start it off with the same processor id (mod _n_parts).
        el->processor_id() = cast_int<processor_id_type>
          (wrap_proc_ids ? old->processor_id() % _n_parts : old->processor_id());

        // Give it the same element and unique ids
        el->set_id(old->id() + element_id_offset);

#ifdef LIBMESH_ENABLE_UNIQUE_ID
        el->set_unique_id() =
          old->unique_id() + unique_id_offset;
#endif

        //Hold onto it
        if (!skip_find_neighbors)
          {
            this->add_elem(el);
          }
        else
          {
            Elem * new_el = this->add_elem(el);
            old_elems_to_new_elems[old] = new_el;
          }

        // Add the link between the original element and this copy to the map
        if (skip_find_neighbors)
          old_elems_to_new_elems[old] = el;
      }

    // Loop (again) over the elements to fill in the neighbors
    if (skip_find_neighbors)
      {
        for (const auto & old_elem : other_mesh.element_ptr_range())
          {
            Elem * new_elem = old_elems_to_new_elems[old_elem];
            for (auto s : old_elem->side_index_range())
              {
                const Elem * old_neighbor = old_elem->neighbor_ptr(s);
                Elem * new_neighbor = old_elems_to_new_elems[old_neighbor];
                new_elem->set_neighbor(s, new_neighbor);
              }
          }
      }
  }

  //Finally prepare the new Mesh for use.  Keep the same numbering and
  //partitioning for now.
  this->allow_renumbering(false);
  this->allow_remote_element_removal(false);
  this->skip_partitioning(true);

  this->prepare_for_use(false, skip_find_neighbors);

  //But in the long term, use the same renumbering and partitioning
  //policies as our source mesh.
  this->allow_renumbering(other_mesh.allow_renumbering());
  this->allow_remote_element_removal(other_mesh.allow_remote_element_removal());
  this->skip_partitioning(other_mesh.skip_partitioning());
}

create_pid_mesh()

void libMesh::UnstructuredMesh::create_pid_mesh ( UnstructuredMesh &  pid_mesh, const processor_id_type  pid  ) const

inherited

Generates a new mesh containing all the elements which are assigned to processor pid. This mesh is written to the pid_mesh reference which you must create and pass to the function.

Definition at line 655 of file unstructured_mesh.C.

References libMesh::MeshBase::active_pid_elements_begin(), libMesh::MeshBase::active_pid_elements_end(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ParallelObject::n_processors(), and libMesh::out.

{

  // Issue a warning if the number the number of processors
  // currently available is less that that requested for
  // partitioning.  This is not necessarily an error since
  // you may run on one processor and still partition the
  // mesh into several partitions.
#ifdef DEBUG
  if (this->n_processors() < pid)
    {
      libMesh::out << "WARNING:  You are creating a "
                   << "mesh for a processor id (="
                   << pid
                   << ") greater than "
                   << "the number of processors available for "
                   << "the calculation. (="
                   << this->n_processors()
                   << ")."
                   << std::endl;
    }
#endif

  this->create_submesh (pid_mesh,
                        this->active_pid_elements_begin(pid),
                        this->active_pid_elements_end(pid));
}

create_submesh()

void libMesh::UnstructuredMesh::create_submesh ( UnstructuredMesh &  new_mesh, const const_element_iterator &  it, const const_element_iterator &  it_end  ) const

inherited

Constructs a mesh called "new_mesh" from the current mesh by iterating over the elements between it and it_end and adding them to the new mesh.

Definition at line 690 of file unstructured_mesh.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::as_range(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), libMesh::DofObject::set_unique_id(), and libMesh::Elem::subdomain_id().

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

{
  // Just in case the subdomain_mesh already has some information
  // in it, get rid of it.
  new_mesh.clear();

  // If we're not serial, our submesh isn't either.
  // There are no remote elements to delete on an empty mesh, but
  // calling the method to do so marks the mesh as parallel.
  if (!this->is_serial())
    new_mesh.delete_remote_elements();

  // Fail if (*this == new_mesh), we cannot create a submesh inside ourself!
  // This may happen if the user accidentally passes the original mesh into
  // this function!  We will check this by making sure we did not just
  // clear ourself.
  libmesh_assert_not_equal_to (this->n_nodes(), 0);
  libmesh_assert_not_equal_to (this->n_elem(), 0);

  // Container to catch boundary IDs handed back by BoundaryInfo
  std::vector<boundary_id_type> bc_ids;

  for (const auto & old_elem : as_range(it, it_end))
    {
      // Add an equivalent element type to the new_mesh.
      // Copy ids for this element.
      Elem * new_elem = Elem::build(old_elem->type()).release();
      new_elem->set_id() = old_elem->id();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      new_elem->set_unique_id() = old_elem->unique_id();
#endif
      new_elem->subdomain_id() = old_elem->subdomain_id();
      new_elem->processor_id() = old_elem->processor_id();

      new_mesh.add_elem (new_elem);

      libmesh_assert(new_elem);

      // Loop over the nodes on this element.
      for (auto n : old_elem->node_index_range())
        {
          const dof_id_type this_node_id = old_elem->node_id(n);

          // Add this node to the new mesh if it's not there already
          if (!new_mesh.query_node_ptr(this_node_id))
            {
#ifdef LIBMESH_ENABLE_UNIQUE_ID
              Node * newn =
#endif
                new_mesh.add_point (old_elem->point(n),
                                    this_node_id,
                                    old_elem->node_ptr(n)->processor_id());

#ifdef LIBMESH_ENABLE_UNIQUE_ID
              newn->set_unique_id() = old_elem->node_ptr(n)->unique_id();
#endif
            }

          // Define this element's connectivity on the new mesh
          new_elem->set_node(n) = new_mesh.node_ptr(this_node_id);
        }

      // Maybe add boundary conditions for this element
      for (auto s : old_elem->side_index_range())
        {
          this->get_boundary_info().boundary_ids(old_elem, s, bc_ids);
          new_mesh.get_boundary_info().add_side (new_elem, s, bc_ids);
        }
    } // end loop over elements

  // Prepare the new_mesh for use
  new_mesh.prepare_for_use(/*skip_renumber =*/false);
}

default_ghosting()

GhostingFunctor& libMesh::MeshBase::default_ghosting ( )

inlineinherited

Default ghosting functor

Definition at line 847 of file mesh_base.h.

References libMesh::MeshBase::_default_ghosting.

{ return *_default_ghosting; }

delete_elem()

void libMesh::ReplicatedMesh::delete_elem ( Elem *  e )

overridevirtual

Removes element e from the mesh. This method must be implemented in derived classes in such a way that it does not invalidate element iterators. Users should call MeshBase::prepare_for_use() after elements are added to and/or deleted from the mesh.

Note

Calling this method may produce isolated nodes, i.e. nodes not connected to any element.

Implements libMesh::MeshBase.

Definition at line 329 of file replicated_mesh.C.

References _elements, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), and libMesh::BoundaryInfo::remove().

Referenced by insert_elem().

{
  libmesh_assert(e);

  // Initialize an iterator to eventually point to the element we want to delete
  std::vector<Elem *>::iterator pos = _elements.end();

  // In many cases, e->id() gives us a clue as to where e
  // is located in the _elements vector.  Try that first
  // before trying the O(n_elem) search.
  libmesh_assert_less (e->id(), _elements.size());

  if (_elements[e->id()] == e)
    {
      // We found it!
      pos = _elements.begin();
      std::advance(pos, e->id());
    }

  else
    {
      // This search is O(n_elem)
      pos = std::find (_elements.begin(),
                       _elements.end(),
                       e);
    }

  // Huh? Element not in the vector?
  libmesh_assert (pos != _elements.end());

  // Remove the element from the BoundaryInfo object
  this->get_boundary_info().remove(e);

  // delete the element
  delete e;

  // explicitly zero the pointer
  *pos = nullptr;
}

delete_node()

void libMesh::ReplicatedMesh::delete_node ( Node *  n )

overridevirtual

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 502 of file replicated_mesh.C.

References _nodes, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), and libMesh::BoundaryInfo::remove().

Referenced by stitching_helper().

{
  libmesh_assert(n);
  libmesh_assert_less (n->id(), _nodes.size());

  // Initialize an iterator to eventually point to the element we want
  // to delete
  std::vector<Node *>::iterator pos;

  // In many cases, e->id() gives us a clue as to where e
  // is located in the _elements vector.  Try that first
  // before trying the O(n_elem) search.
  if (_nodes[n->id()] == n)
    {
      pos = _nodes.begin();
      std::advance(pos, n->id());
    }
  else
    {
      pos = std::find (_nodes.begin(),
                       _nodes.end(),
                       n);
    }

  // Huh? Node not in the vector?
  libmesh_assert (pos != _nodes.end());

  // Delete the node from the BoundaryInfo object
  this->get_boundary_info().remove(n);

  // delete the node
  delete n;

  // explicitly zero the pointer
  *pos = nullptr;
}

delete_remote_elements()

virtual void libMesh::MeshBase::delete_remote_elements ( )

inlinevirtualinherited

When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local element, and deletes all nodes which are not part of a local or ghost element

Reimplemented in libMesh::DistributedMesh.

Definition at line 196 of file mesh_base.h.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::BoundaryInfo::sync(), and libMesh::MeshSerializer::~MeshSerializer().

{}

detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )

inherited

Search the mesh for elements that have a neighboring element of dim+1 and set that element as the interior parent

Definition at line 633 of file mesh_base.C.

References libMesh::MeshBase::active_element_ptr_range(), libMesh::Elem::dim(), libMesh::MeshBase::elem(), libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), libMesh::MeshBase::element_ptr_range(), libMesh::DofObject::id(), libMesh::MeshBase::max_elem_id(), libMesh::Elem::n_vertices(), and libMesh::Elem::node_id().

Referenced by libMesh::MeshBase::prepare_for_use().

{
  // This requires an inspection on every processor
  parallel_object_only();

  // Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
  if (this->elem_dimensions().size() == 1)
    return;

  //This map will be used to set interior parents
  std::unordered_map<dof_id_type, std::vector<dof_id_type>> node_to_elem;

  for (const auto & elem : this->active_element_ptr_range())
    {
      // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
      for (unsigned int n=0; n<elem->n_vertices(); n++)
        {
          libmesh_assert_less (elem->id(), this->max_elem_id());

          node_to_elem[elem->node_id(n)].push_back(elem->id());
        }
    }

  // Automatically set interior parents
  for (const auto & element : this->element_ptr_range())
    {
      // Ignore an 3D element or an element that already has an interior parent
      if (element->dim()>=LIBMESH_DIM || element->interior_parent())
        continue;

      // Start by generating a SET of elements that are dim+1 to the current
      // element at each vertex of the current element, thus ignoring interior nodes.
      // If one of the SET of elements is empty, then we will not have an interior parent
      // since an interior parent must be connected to all vertices of the current element
      std::vector<std::set<dof_id_type>> neighbors( element->n_vertices() );

      bool found_interior_parents = false;

      for (dof_id_type n=0; n < element->n_vertices(); n++)
        {
          std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
          for (const auto & eid : element_ids)
            if (this->elem_ref(eid).dim() == element->dim()+1)
              neighbors[n].insert(eid);

          if (neighbors[n].size()>0)
            {
              found_interior_parents = true;
            }
          else
            {
              // We have found an empty set, no reason to continue
              // Ensure we set this flag to false before the break since it could have
              // been set to true for previous vertex
              found_interior_parents = false;
              break;
            }
        }

      // If we have successfully generated a set of elements for each vertex, we will compare
      // the set for vertex 0 will the sets for the vertices until we find a id that exists in
      // all sets.  If found, this is our an interior parent id.  The interior parent id found
      // will be the lowest element id if there is potential for multiple interior parents.
      if (found_interior_parents)
        {
          std::set<dof_id_type> & neighbors_0 = neighbors[0];
          for (const auto & interior_parent_id : neighbors_0)
            {
              found_interior_parents = false;
              for (dof_id_type n=1; n < element->n_vertices(); n++)
                {
                  if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
                    {
                      found_interior_parents=true;
                    }
                  else
                    {
                      found_interior_parents=false;
                      break;
                    }
                }
              if (found_interior_parents)
                {
                  element->set_interior_parent(this->elem_ptr(interior_parent_id));
                  break;
                }
            }
        }
    }
}

elem() [1/2]

virtual const Elem* libMesh::MeshBase::elem ( const dof_id_type  i ) const

inlinevirtualinherited

Returns

A pointer to the element, which should be present in this processor's subset of the mesh data structure.

Deprecated:

Use the less confusingly-named elem_ptr() instead.

Definition at line 537 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::MeshBase::cache_elem_dims(), clear(), libMesh::DistributedMesh::clear(), libMesh::UnstructuredMesh::contract(), libMesh::MeshBase::detect_interior_parents(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshBase::n_active_sub_elem(), libMesh::MeshBase::n_sub_elem(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::DistributedMesh::renumber_nodes_and_elements(), and libMesh::MeshBase::subdomain_ids().

  {
    libmesh_deprecated();
    return this->elem_ptr(i);
  }

elem() [2/2]

virtual Elem* libMesh::MeshBase::elem ( const dof_id_type  i )

inlinevirtualinherited

Returns

A writable pointer to the element, which should be present in this processor's subset of the mesh data structure.

Deprecated:

Use the less confusingly-named elem_ptr() instead.

Definition at line 552 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

  {
    libmesh_deprecated();
    return this->elem_ptr(i);
  }

elem_dimensions()

const std::set<unsigned char>& libMesh::MeshBase::elem_dimensions ( ) const

inlineinherited

Returns

A const reference to a std::set of element dimensions present in the mesh.

Definition at line 220 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::System::calculate_norm(), libMesh::MeshBase::detect_interior_parents(), and libMesh::TreeNode< N >::insert().

  { return _elem_dims; }

elem_ptr() [1/2]

const Elem * libMesh::ReplicatedMesh::elem_ptr ( const dof_id_type  i ) const

overridevirtual

Returns

A pointer to the element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 219 of file replicated_mesh.C.

References _elements, and n_elem().

Referenced by stitching_helper().

{
  libmesh_assert_less (i, this->n_elem());
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i); // This will change soon

  return _elements[i];
}

elem_ptr() [2/2]

Elem * libMesh::ReplicatedMesh::elem_ptr ( const dof_id_type  i )

overridevirtual

Returns

A writable pointer to the element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 231 of file replicated_mesh.C.

References _elements, and n_elem().

{
  libmesh_assert_less (i, this->n_elem());
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i); // This will change soon

  return _elements[i];
}

elem_ref() [1/2]

virtual const Elem& libMesh::MeshBase::elem_ref ( const dof_id_type  i ) const

inlinevirtualinherited

Returns

A reference to the element, which should be present in this processor's subset of the mesh data structure.

Definition at line 504 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::SyncRefinementFlags::act_on_data(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::MeshBase::detect_interior_parents(), libMesh::SyncRefinementFlags::gather_data(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_remote_elem(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::FroIO::write(), libMesh::Nemesis_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

                                                            {
    return *this->elem_ptr(i);
  }

elem_ref() [2/2]

virtual Elem& libMesh::MeshBase::elem_ref ( const dof_id_type  i )

inlinevirtualinherited

Returns

A writable reference to the element, which should be present in this processor's subset of the mesh data structure.

Definition at line 513 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

                                                {
    return *this->elem_ptr(i);
  }

element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::ReplicatedMesh::element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 239 of file replicated_mesh.h.

References elements_begin(), and elements_end().

Referenced by stitching_helper().

{ return {elements_begin(), elements_end()}; }

element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::ReplicatedMesh::element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 240 of file replicated_mesh.h.

References elements_begin(), and elements_end().

{ return {elements_begin(), elements_end()}; }

elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::elements_begin ( )

overridevirtual

Elem iterator accessor functions.

Implements libMesh::MeshBase.

Referenced by element_ptr_range().

elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by element_ptr_range().

elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::evaluable_elements_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Iterate over elements in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default.

Implements libMesh::MeshBase.

evaluable_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::evaluable_elements_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::evaluable_elements_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Implements libMesh::MeshBase.

evaluable_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::evaluable_elements_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::evaluable_nodes_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Iterate over nodes in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default.

Implements libMesh::MeshBase.

evaluable_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::evaluable_nodes_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::evaluable_nodes_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::evaluable_nodes_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

facelocal_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::facelocal_elements_begin ( )

overridevirtual

Iterate over elements which are on or have a neighbor on the current processor.

Implements libMesh::MeshBase.

facelocal_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::facelocal_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

facelocal_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::facelocal_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

facelocal_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::facelocal_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

find_neighbors()

void libMesh::UnstructuredMesh::find_neighbors ( const bool  reset_remote_elements = false, const bool  reset_current_list = true  )

overridevirtualinherited

Other functions from MeshBase requiring re-definition.

Here we look at all of the child elements which don't already have valid neighbors.

If a child element has a nullptr neighbor it is either because it is on the boundary or because its neighbor is at a different level. In the latter case we must get the neighbor from the parent.

If a child element has a remote_elem neighbor on a boundary it shares with its parent, that info may have become out-dated through coarsening of the neighbor's parent. In this case, if the parent's neighbor is active then the child should share it.

Furthermore, that neighbor better be active, otherwise we missed a child somewhere.

We also need to look through children ordered by increasing refinement level in order to add new interior_parent() links in boundary elements which have just been generated by refinement, and fix links in boundary elements whose previous interior_parent() has just been coarsened away.

Implements libMesh::MeshBase.

Definition at line 240 of file unstructured_mesh.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::as_range(), libMesh::Elem::centroid(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::MeshBase::element_ptr_range(), libMesh::err, libMesh::Elem::has_children(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::Elem::is_ancestor_of(), libMesh::Elem::is_child_on_side(), libMesh::Elem::level(), libMesh::MeshBase::level_elements_begin(), libMesh::MeshBase::level_elements_end(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::n_children(), libMesh::MeshTools::n_levels(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::remote_elem, libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::Elem::side_ptr(), libMesh::Elem::subactive(), libMesh::TOLERANCE, libMesh::Elem::which_child_am_i(), and libMesh::NameBasedIO::write().

Referenced by libMesh::TriangleWrapper::copy_tri_to_mesh(), and libMesh::DistributedMesh::redistribute().

{
  // We might actually want to run this on an empty mesh
  // (e.g. the boundary mesh for a nonexistent bcid!)
  // libmesh_assert_not_equal_to (this->n_nodes(), 0);
  // libmesh_assert_not_equal_to (this->n_elem(), 0);

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

  LOG_SCOPE("find_neighbors()", "Mesh");

  //TODO:[BSK] This should be removed later?!
  if (reset_current_list)
    for (const auto & e : this->element_ptr_range())
      for (auto s : e->side_index_range())
        if (e->neighbor_ptr(s) != remote_elem || reset_remote_elements)
          e->set_neighbor(s, nullptr);

  // Find neighboring elements by first finding elements
  // with identical side keys and then check to see if they
  // are neighbors
  {
    // data structures -- Use the hash_multimap if available
    typedef unsigned int                    key_type;
    typedef std::pair<Elem *, unsigned char> val_type;
    typedef std::pair<key_type, val_type>   key_val_pair;

    typedef std::unordered_multimap<key_type, val_type> map_type;

    // A map from side keys to corresponding elements & side numbers
    map_type side_to_elem_map;

    // Pull objects out of the loop to reduce heap operations
    std::unique_ptr<Elem> my_side, their_side;

    for (const auto & element : this->element_ptr_range())
      {
        for (auto ms : element->side_index_range())
          {
          next_side:
            // If we haven't yet found a neighbor on this side, try.
            // Even if we think our neighbor is remote, that
            // information may be out of date.
            if (element->neighbor_ptr(ms) == nullptr ||
                element->neighbor_ptr(ms) == remote_elem)
              {
                // Get the key for the side of this element
                const unsigned int key = element->key(ms);

                // Look for elements that have an identical side key
                auto bounds = side_to_elem_map.equal_range(key);

                // May be multiple keys, check all the possible
                // elements which _might_ be neighbors.
                if (bounds.first != bounds.second)
                  {
                    // Get the side for this element
                    element->side_ptr(my_side, ms);

                    // Look at all the entries with an equivalent key
                    while (bounds.first != bounds.second)
                      {
                        // Get the potential element
                        Elem * neighbor = bounds.first->second.first;

                        // Get the side for the neighboring element
                        const unsigned int ns = bounds.first->second.second;
                        neighbor->side_ptr(their_side, ns);
                        //libmesh_assert(my_side.get());
                        //libmesh_assert(their_side.get());

                        // If found a match with my side
                        //
                        // We need special tests here for 1D:
                        // since parents and children have an equal
                        // side (i.e. a node), we need to check
                        // ns != ms, and we also check level() to
                        // avoid setting our neighbor pointer to
                        // any of our neighbor's descendants
                        if ((*my_side == *their_side) &&
                            (element->level() == neighbor->level()) &&
                            ((element->dim() != 1) || (ns != ms)))
                          {
                            // So share a side.  Is this a mixed pair
                            // of subactive and active/ancestor
                            // elements?
                            // If not, then we're neighbors.
                            // If so, then the subactive's neighbor is

                            if (element->subactive() ==
                                neighbor->subactive())
                              {
                                // an element is only subactive if it has
                                // been coarsened but not deleted
                                element->set_neighbor (ms,neighbor);
                                neighbor->set_neighbor(ns,element);
                              }
                            else if (element->subactive())
                              {
                                element->set_neighbor(ms,neighbor);
                              }
                            else if (neighbor->subactive())
                              {
                                neighbor->set_neighbor(ns,element);
                              }
                            side_to_elem_map.erase (bounds.first);

                            // get out of this nested crap
                            goto next_side;
                          }

                        ++bounds.first;
                      }
                  }

                // didn't find a match...
                // Build the map entry for this element
                key_val_pair kvp;

                kvp.first         = key;
                kvp.second.first  = element;
                kvp.second.second = cast_int<unsigned char>(ms);
                side_to_elem_map.insert (kvp);
              }
          }
      }
  }

#ifdef LIBMESH_ENABLE_AMR

  const unsigned int n_levels = MeshTools::n_levels(*this);
  for (unsigned int level = 1; level < n_levels; ++level)
    {
      for (auto & current_elem : as_range(level_elements_begin(level),
                                          level_elements_end(level)))
        {
          libmesh_assert(current_elem);
          Elem * parent = current_elem->parent();
          libmesh_assert(parent);
          const unsigned int my_child_num = parent->which_child_am_i(current_elem);

          for (auto s : current_elem->side_index_range())
            {
              if (current_elem->neighbor_ptr(s) == nullptr ||
                  (current_elem->neighbor_ptr(s) == remote_elem &&
                   parent->is_child_on_side(my_child_num, s)))
                {
                  Elem * neigh = parent->neighbor_ptr(s);

                  // If neigh was refined and had non-subactive children
                  // made remote earlier, then our current elem should
                  // actually have one of those remote children as a
                  // neighbor
                  if (neigh &&
                      (neigh->ancestor() ||
                       // If neigh has subactive children which should have
                       // matched as neighbors of the current element but
                       // did not, then those likewise must be remote
                       // children.
                       (current_elem->subactive() && neigh->has_children() &&
                        (neigh->level()+1) == current_elem->level())))
                    {
#ifdef DEBUG
                      // Let's make sure that "had children made remote"
                      // situation is actually the case
                      libmesh_assert(neigh->has_children());
                      bool neigh_has_remote_children = false;
                      for (auto & child : neigh->child_ref_range())
                        if (&child == remote_elem)
                          neigh_has_remote_children = true;
                      libmesh_assert(neigh_has_remote_children);

                      // And let's double-check that we don't have
                      // a remote_elem neighboring an active local element
                      if (current_elem->active())
                        libmesh_assert_not_equal_to (current_elem->processor_id(),
                                                     this->processor_id());
#endif // DEBUG
                      neigh = const_cast<RemoteElem *>(remote_elem);
                    }
                  // If neigh and current_elem are more than one level
                  // apart, figuring out whether we have a remote
                  // neighbor here becomes much harder.
                  else if (neigh && (current_elem->subactive() &&
                                     neigh->has_children()))
                    {
                      // Find the deepest descendant of neigh which
                      // we could consider for a neighbor.  If we run
                      // out of neigh children, then that's our
                      // neighbor.  If we find a potential neighbor
                      // with remote_children and we don't find any
                      // potential neighbors among its non-remote
                      // children, then our neighbor must be remote.
                      while (neigh != remote_elem &&
                             neigh->has_children())
                        {
                          bool found_neigh = false;
                          for (unsigned int c = 0, nc = neigh->n_children();
                               !found_neigh && c != nc; ++c)
                            {
                              Elem * child = neigh->child_ptr(c);
                              if (child == remote_elem)
                                continue;
                              for (auto ncn : child->neighbor_ptr_range())
                                {
                                  if (ncn != remote_elem &&
                                      ncn->is_ancestor_of(current_elem))
                                    {
                                      neigh = ncn;
                                      found_neigh = true;
                                      break;
                                    }
                                }
                            }
                          if (!found_neigh)
                            neigh = const_cast<RemoteElem *>(remote_elem);
                        }
                    }
                  current_elem->set_neighbor(s, neigh);
#ifdef DEBUG
                  if (neigh != nullptr && neigh != remote_elem)
                    // We ignore subactive elements here because
                    // we don't care about neighbors of subactive element.
                    if ((!neigh->active()) && (!current_elem->subactive()))
                      {
                        libMesh::err << "On processor " << this->processor_id()
                                     << std::endl;
                        libMesh::err << "Bad element ID = " << current_elem->id()
                                     << ", Side " << s << ", Bad neighbor ID = " << neigh->id() << std::endl;
                        libMesh::err << "Bad element proc_ID = " << current_elem->processor_id()
                                     << ", Bad neighbor proc_ID = " << neigh->processor_id() << std::endl;
                        libMesh::err << "Bad element size = " << current_elem->hmin()
                                     << ", Bad neighbor size = " << neigh->hmin() << std::endl;
                        libMesh::err << "Bad element center = " << current_elem->centroid()
                                     << ", Bad neighbor center = " << neigh->centroid() << std::endl;
                        libMesh::err << "ERROR: "
                                     << (current_elem->active()?"Active":"Ancestor")
                                     << " Element at level "
                                     << current_elem->level() << std::endl;
                        libMesh::err << "with "
                                     << (parent->active()?"active":
                                         (parent->subactive()?"subactive":"ancestor"))
                                     << " parent share "
                                     << (neigh->subactive()?"subactive":"ancestor")
                                     << " neighbor at level " << neigh->level()
                                     << std::endl;
                        NameBasedIO(*this).write ("bad_mesh.gmv");
                        libmesh_error_msg("Problematic mesh written to bad_mesh.gmv.");
                      }
#endif // DEBUG
                }
            }

          // We can skip to the next element if we're full-dimension
          // and therefore don't have any interior parents
          if (current_elem->dim() >= LIBMESH_DIM)
            continue;

          // We have no interior parents unless we can find one later
          current_elem->set_interior_parent(nullptr);

          Elem * pip = parent->interior_parent();

          if (!pip)
            continue;

          // If there's no interior_parent children, whether due to a
          // remote element or a non-conformity, then there's no
          // children to search.
          if (pip == remote_elem || pip->active())
            {
              current_elem->set_interior_parent(pip);
              continue;
            }

          // For node comparisons we'll need a sensible tolerance
          Real node_tolerance = current_elem->hmin() * TOLERANCE;

          // Otherwise our interior_parent should be a child of our
          // parent's interior_parent.
          for (auto & child : pip->child_ref_range())
            {
              // If we have a remote_elem, that might be our
              // interior_parent.  We'll set it provisionally now and
              // keep trying to find something better.
              if (&child == remote_elem)
                {
                  current_elem->set_interior_parent
                    (const_cast<RemoteElem *>(remote_elem));
                  continue;
                }

              bool child_contains_our_nodes = true;
              for (auto & n : current_elem->node_ref_range())
                {
                  bool child_contains_this_node = false;
                  for (auto & cn : child.node_ref_range())
                    if (cn.absolute_fuzzy_equals
                        (n, node_tolerance))
                      {
                        child_contains_this_node = true;
                        break;
                      }
                  if (!child_contains_this_node)
                    {
                      child_contains_our_nodes = false;
                      break;
                    }
                }
              if (child_contains_our_nodes)
                {
                  current_elem->set_interior_parent(&child);
                  break;
                }
            }

          // We should have found *some* interior_parent at this
          // point, whether semilocal or remote.
          libmesh_assert(current_elem->interior_parent());
        }
    }

#endif // AMR


#ifdef DEBUG
  MeshTools::libmesh_assert_valid_neighbors(*this,
                                            !reset_remote_elements);
  MeshTools::libmesh_assert_valid_amr_interior_parents(*this);
#endif
}

fix_broken_node_and_element_numbering()

void libMesh::ReplicatedMesh::fix_broken_node_and_element_numbering ( )

overridevirtual

There is no reason for a user to ever call this function.

This function restores a previously broken element/node numbering such that mesh.node_ref(n).id() == n.

Implements libMesh::MeshBase.

Definition at line 761 of file replicated_mesh.C.

References _elements, and _nodes.

{
  // Nodes first
  for (std::size_t n=0; n<this->_nodes.size(); n++)
    if (this->_nodes[n] != nullptr)
      this->_nodes[n]->set_id() = cast_int<dof_id_type>(n);

  // Elements next
  for (std::size_t e=0; e<this->_elements.size(); e++)
    if (this->_elements[e] != nullptr)
      this->_elements[e]->set_id() = cast_int<dof_id_type>(e);
}

flagged_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::flagged_elements_begin ( unsigned char  rflag )

overridevirtual

Iterate over all elements with a specified refinement flag.

Implements libMesh::MeshBase.

flagged_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::flagged_elements_begin ( unsigned char  rflag ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::flagged_elements_end ( unsigned char  rflag )

overridevirtual

Implements libMesh::MeshBase.

flagged_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::flagged_elements_end ( unsigned char  rflag ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::flagged_pid_elements_begin ( unsigned char  rflag, processor_id_type  pid  )

overridevirtual

Iterate over all elements with a specified refinement flag on a specified processor.

Implements libMesh::MeshBase.

flagged_pid_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::flagged_pid_elements_begin ( unsigned char  rflag, processor_id_type  pid  ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::flagged_pid_elements_end ( unsigned char  rflag, processor_id_type  pid  )

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::flagged_pid_elements_end ( unsigned char  rflag, processor_id_type  pid  ) const

overridevirtual

Implements libMesh::MeshBase.

gather_to_zero()

virtual void libMesh::MeshBase::gather_to_zero ( )

inlinevirtualinherited

Gathers all elements and nodes of the mesh onto processor zero

Reimplemented in libMesh::DistributedMesh.

Definition at line 189 of file mesh_base.h.

Referenced by libMesh::MeshSerializer::MeshSerializer().

{}

get_boundary_info() [1/2]

const BoundaryInfo& libMesh::MeshBase::get_boundary_info ( ) const

inlineinherited

The information about boundary ids on the mesh

Definition at line 131 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), delete_elem(), libMesh::DistributedMesh::delete_elem(), delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::UNVIO::groups_in(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::Parallel::Packing< T >::pack(), libMesh::Parallel::Packing< T >::packable_size(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_header(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_nodesets(), renumber_nodes_and_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), ReplicatedMesh(), stitching_helper(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::Packing< T >::unpack(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

{ return *boundary_info; }

get_boundary_info() [2/2]

BoundaryInfo& libMesh::MeshBase::get_boundary_info ( )

inlineinherited

Writable information about boundary ids on the mesh

Definition at line 136 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

{ return *boundary_info; }

get_count_lower_dim_elems_in_point_locator()

bool libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator ( ) const

inherited

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 531 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

Referenced by libMesh::TreeNode< N >::insert().

{
  return _count_lower_dim_elems_in_point_locator;
}

get_id_by_name()

subdomain_id_type libMesh::MeshBase::get_id_by_name ( const std::string &  name ) const

inherited

Returns

The id of the named subdomain if it exists, Elem::invalid_subdomain_id otherwise.

Definition at line 558 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name, libMesh::Elem::invalid_subdomain_id, and libMesh::Quality::name().

{
  // Linear search over the map values.
  std::map<subdomain_id_type, std::string>::const_iterator
    iter = _block_id_to_name.begin(),
    end_iter = _block_id_to_name.end();

  for ( ; iter != end_iter; ++iter)
    if (iter->second == name)
      return iter->first;

  // If we made it here without returning, we don't have a subdomain
  // with the requested name, so return Elem::invalid_subdomain_id.
  return Elem::invalid_subdomain_id;
}

get_info()

std::string libMesh::MeshBase::get_info ( ) const

inherited

Returns

A string containing relevant information about the mesh.

Definition at line 378 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::n_subdomains(), libMesh::n_threads(), libMesh::ParallelObject::processor_id(), and libMesh::MeshBase::spatial_dimension().

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

{
  std::ostringstream oss;

  oss << " Mesh Information:"                                  << '\n';

  if (!_elem_dims.empty())
    {
      oss << "  elem_dimensions()={";
      std::copy(_elem_dims.begin(),
                --_elem_dims.end(), // --end() is valid if the set is non-empty
                std::ostream_iterator<unsigned int>(oss, ", "));
      oss << cast_int<unsigned int>(*_elem_dims.rbegin());
      oss << "}\n";
    }

  oss << "  spatial_dimension()=" << this->spatial_dimension() << '\n'
      << "  n_nodes()="           << this->n_nodes()           << '\n'
      << "    n_local_nodes()="   << this->n_local_nodes()     << '\n'
      << "  n_elem()="            << this->n_elem()            << '\n'
      << "    n_local_elem()="    << this->n_local_elem()      << '\n'
#ifdef LIBMESH_ENABLE_AMR
      << "    n_active_elem()="   << this->n_active_elem()     << '\n'
#endif
      << "  n_subdomains()="      << static_cast<std::size_t>(this->n_subdomains()) << '\n'
      << "  n_partitions()="      << static_cast<std::size_t>(this->n_partitions()) << '\n'
      << "  n_processors()="      << static_cast<std::size_t>(this->n_processors()) << '\n'
      << "  n_threads()="         << static_cast<std::size_t>(libMesh::n_threads()) << '\n'
      << "  processor_id()="      << static_cast<std::size_t>(this->processor_id()) << '\n';

  return oss.str();
}

get_subdomain_name_map()

const std::map<subdomain_id_type, std::string>& libMesh::MeshBase::get_subdomain_name_map ( ) const

inlineinherited

Definition at line 1337 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

  { return _block_id_to_name; }

ghost_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::ghost_elements_begin ( )

overridevirtual

Iterate over "ghost" elements in the Mesh. A ghost element is one which is not local, but is semilocal.

Implements libMesh::MeshBase.

ghost_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::ghost_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

ghost_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::ghost_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

ghost_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::ghost_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

ghosting_functors_begin()

std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_begin ( ) const

inlineinherited

Beginning of range of ghosting functors

Definition at line 835 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), and libMesh::query_ghosting_functors().

  { return _ghosting_functors.begin(); }

ghosting_functors_end()

std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_end ( ) const

inlineinherited

End of range of ghosting functors

Definition at line 841 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), and libMesh::query_ghosting_functors().

  { return _ghosting_functors.end(); }

insert_elem()

Elem * libMesh::ReplicatedMesh::insert_elem ( Elem *  e )

overridevirtual

Insert elem e to the element array, preserving its id and replacing/deleting any existing element with the same id.

Users should call MeshBase::prepare_for_use() after elements are added to and/or deleted from the mesh.

Implements libMesh::MeshBase.

Definition at line 305 of file replicated_mesh.C.

References _elements, libMesh::MeshBase::_next_unique_id, delete_elem(), libMesh::DofObject::id(), libMesh::DofObject::set_unique_id(), and libMesh::DofObject::valid_unique_id().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    e->set_unique_id() = _next_unique_id++;
#endif

  dof_id_type eid = e->id();
  libmesh_assert_less (eid, _elements.size());
  Elem * oldelem = _elements[eid];

  if (oldelem)
    {
      libmesh_assert_equal_to (oldelem->id(), eid);
      this->delete_elem(oldelem);
    }

  _elements[e->id()] = e;

  return e;
}

insert_node()

Node * libMesh::ReplicatedMesh::insert_node ( Node *  n )

overridevirtual

Insert Node n into the Mesh at a location consistent with n->id(), allocating extra storage if necessary. Throws an error if: .) n==nullptr .) n->id() == DofObject::invalid_id .) A node already exists in position n->id().

This function differs from the ReplicatedMesh::add_node() function, which is only capable of appending nodes at the end of the nodes storage.

Implements libMesh::MeshBase.

Definition at line 459 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, _nodes, libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::DofObject::set_unique_id(), and libMesh::DofObject::valid_unique_id().

{
  if (!n)
    libmesh_error_msg("Error, attempting to insert nullptr node.");

  if (n->id() == DofObject::invalid_id)
    libmesh_error_msg("Error, cannot insert node with invalid id.");

  if (n->id() < _nodes.size())
    {
      // Don't allow inserting on top of an existing Node.

      // Doing so doesn't have to be *error*, in the case where a
      // redundant insert is done, but when that happens we ought to
      // always be able to make the code more efficient by avoiding
      // the redundant insert, so let's keep screaming "Error" here.
      if (_nodes[ n->id() ] != nullptr)
        libmesh_error_msg("Error, cannot insert node on top of existing node.");
    }
  else
    {
      // Allocate just enough space to store the new node.  This will
      // cause highly non-ideal memory allocation behavior if called
      // repeatedly...
      _nodes.resize(n->id() + 1);
    }

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!n->valid_unique_id())
    n->set_unique_id() = _next_unique_id++;
#endif

  // We have enough space and this spot isn't already occupied by
  // another node, so go ahead and add it.
  _nodes[ n->id() ] = n;

  // If we made it this far, we just inserted the node the user handed
  // us, so we can give it right back.
  return n;
}

is_prepared()

bool libMesh::MeshBase::is_prepared ( ) const

inlineinherited

Returns

true if the mesh has been prepared via a call to prepare_for_use, false otherwise.

Definition at line 147 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

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

  { return _is_prepared; }

is_replicated()

virtual bool libMesh::MeshBase::is_replicated ( ) const

inlinevirtualinherited

Returns

true if new elements and nodes can and should be created in synchronization on all processors, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 176 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::CheckpointIO::read(), and libMesh::MeshRefinement::uniformly_coarsen().

  { return true; }

is_serial()

virtual bool libMesh::MeshBase::is_serial ( ) const

inlinevirtualinherited

Returns

true if all elements and nodes of the mesh exist on the current processor, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 154 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::allgather(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::LocationMap< T >::init(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshSerializer::MeshSerializer(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::MeshBase::partition(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::DofMap::scatter_constraints(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::total_weight(), libMesh::CheckpointIO::write(), and libMesh::XdrIO::write_parallel().

  { return true; }

is_serial_on_zero()

virtual bool libMesh::MeshBase::is_serial_on_zero ( ) const

inlinevirtualinherited

Returns

true if all elements and nodes of the mesh exist on the processor 0, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 161 of file mesh_base.h.

  { return true; }

level_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::level_elements_begin ( unsigned int  level )

overridevirtual

Iterate over elements of a given level.

Implements libMesh::MeshBase.

level_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

level_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

level_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

libmesh_assert_valid_parallel_ids()

virtual void libMesh::MeshBase::libmesh_assert_valid_parallel_ids ( ) const

inlinevirtualinherited

Verify id and processor_id consistency of our elements and nodes containers. Calls libmesh_assert() on each possible failure. Currently only implemented on DistributedMesh; a serial data structure is much harder to get out of sync.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1007 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::InfElemBuilder::build_inf_elem(), and libMesh::MeshRefinement::refine_and_coarsen_elements().

{}

local_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

local_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

local_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_node_ptr_range() [1/2]

virtual SimpleRange<node_iterator> libMesh::ReplicatedMesh::local_node_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 432 of file replicated_mesh.h.

References local_nodes_begin(), and local_nodes_end().

{ return {local_nodes_begin(), local_nodes_end()}; }

local_node_ptr_range() [2/2]

virtual SimpleRange<const_node_iterator> libMesh::ReplicatedMesh::local_node_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 433 of file replicated_mesh.h.

References local_nodes_begin(), and local_nodes_end().

{ return {local_nodes_begin(), local_nodes_end()}; }

local_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::local_nodes_begin ( )

overridevirtual

Iterate over local nodes (nodes whose processor_id() matches the current processor).

Implements libMesh::MeshBase.

Referenced by local_node_ptr_range().

local_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::local_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::local_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by local_node_ptr_range().

local_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::local_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_not_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_not_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::local_not_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::local_not_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

max_elem_id()

virtual dof_id_type libMesh::ReplicatedMesh::max_elem_id ( ) const

inlineoverridevirtual

Returns

A number greater than or equal to the maximum element id in the mesh.

Implements libMesh::MeshBase.

Definition at line 123 of file replicated_mesh.h.

References _elements.

Referenced by stitching_helper().

  { return cast_int<dof_id_type>(_elements.size()); }

max_node_id()

virtual dof_id_type libMesh::ReplicatedMesh::max_node_id ( ) const

inlineoverridevirtual

Returns

A number greater than or equal to the maximum node id in the mesh.

Implements libMesh::MeshBase.

Definition at line 109 of file replicated_mesh.h.

References _nodes.

Referenced by stitching_helper().

  { return cast_int<dof_id_type>(_nodes.size()); }

mesh_dimension()

unsigned int libMesh::MeshBase::mesh_dimension ( ) const

inherited

Returns

The logical dimension of the mesh; i.e. the manifold dimension of the elements in the mesh. If we ever support multi-dimensional meshes (e.g. hexes and quads in the same mesh) then this will return the largest such dimension.

Definition at line 126 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::MeshBase::cache_elem_dims(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::distort(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::LaplaceMeshSmoother::init(), libMesh::PointLocatorTree::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GMVIO::read(), libMesh::VTKIO::read(), libMesh::System::read_header(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::MeshTools::Modification::smooth(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_nodal_data(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), and libMesh::EnsightIO::write_vector_ascii().

{
  if (!_elem_dims.empty())
    return cast_int<unsigned int>(*_elem_dims.rbegin());
  return 0;
}

n_active_elem()

dof_id_type libMesh::ReplicatedMesh::n_active_elem ( ) const

overridevirtual

Returns

The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

Definition at line 1371 of file replicated_mesh.C.

References active_elements_begin(), and active_elements_end().

{
  return static_cast<dof_id_type>(std::distance (this->active_elements_begin(),
                                                 this->active_elements_end()));
}

n_active_elem_on_proc()

dof_id_type libMesh::MeshBase::n_active_elem_on_proc ( const processor_id_type  proc ) const

inherited

Returns

The number of active elements on processor proc.

Definition at line 345 of file mesh_base.C.

References libMesh::MeshBase::active_pid_elements_begin(), libMesh::MeshBase::active_pid_elements_end(), and libMesh::ParallelObject::n_processors().

Referenced by libMesh::MeshBase::n_active_local_elem().

{
  libmesh_assert_less (proc_id, this->n_processors());
  return static_cast<dof_id_type>(std::distance (this->active_pid_elements_begin(proc_id),
                                                 this->active_pid_elements_end  (proc_id)));
}

n_active_local_elem()

dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const

inlineinherited

Returns

The number of active elements on the local processor.

Definition at line 403 of file mesh_base.h.

References libMesh::MeshBase::n_active_elem_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::VTKIO::cells_to_vtk().

  { return this->n_active_elem_on_proc (this->processor_id()); }

n_active_sub_elem()

dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const

inherited

Same as n_sub_elem(), but only counts active elements.

Definition at line 366 of file mesh_base.C.

References libMesh::MeshBase::active_element_ptr_range(), libMesh::MeshBase::elem(), and libMesh::Elem::n_sub_elem().

Referenced by libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_old_impl(), and libMesh::TecplotIO::write_binary().

{
  dof_id_type ne=0;

  for (const auto & elem : this->active_element_ptr_range())
    ne += elem->n_sub_elem();

  return ne;
}

n_elem()

virtual dof_id_type libMesh::ReplicatedMesh::n_elem ( ) const

inlineoverridevirtual

Returns

The number of elements in the mesh.

The standard n_elem() function may return a cached value on distributed meshes, and so can be called by any processor at any time.

Implements libMesh::MeshBase.

Definition at line 115 of file replicated_mesh.h.

References _elements.

Referenced by elem_ptr(), and query_elem_ptr().

  { return cast_int<dof_id_type>(_elements.size()); }

n_elem_on_proc()

dof_id_type libMesh::MeshBase::n_elem_on_proc ( const processor_id_type  proc ) const

inherited

Returns

The number of elements on processor proc.

Definition at line 332 of file mesh_base.C.

References libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::pid_elements_begin(), and libMesh::MeshBase::pid_elements_end().

Referenced by libMesh::MeshBase::n_local_elem(), and libMesh::MeshBase::n_unpartitioned_elem().

{
  // We're either counting a processor's elements or unpartitioned
  // elements
  libmesh_assert (proc_id < this->n_processors() ||
                  proc_id == DofObject::invalid_processor_id);

  return static_cast<dof_id_type>(std::distance (this->pid_elements_begin(proc_id),
                                                 this->pid_elements_end  (proc_id)));
}

n_local_elem()

dof_id_type libMesh::MeshBase::n_local_elem ( ) const

inlineinherited

Returns

The number of elements on the local processor.

Definition at line 386 of file mesh_base.h.

References libMesh::MeshBase::n_elem_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::MeshBase::get_info(), and libMesh::DistributedMesh::parallel_n_elem().

  { return this->n_elem_on_proc (this->processor_id()); }

n_local_nodes()

dof_id_type libMesh::MeshBase::n_local_nodes ( ) const

inlineinherited

Returns

The number of nodes on the local processor.

Definition at line 286 of file mesh_base.h.

References libMesh::MeshBase::n_nodes_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::MeshBase::get_info(), libMesh::VTKIO::nodes_to_vtk(), and libMesh::DistributedMesh::parallel_n_nodes().

  { return this->n_nodes_on_proc (this->processor_id()); }

n_nodes()

virtual dof_id_type libMesh::ReplicatedMesh::n_nodes ( ) const

inlineoverridevirtual

Returns

The number of nodes in the mesh.

This function and others must be defined in derived classes since the MeshBase class has no specific storage for nodes or elements. The standard n_nodes() function may return a cached value on distributed meshes, and so can be called by any processor at any time.

Implements libMesh::MeshBase.

Definition at line 103 of file replicated_mesh.h.

References _nodes.

Referenced by node_ptr(), and query_node_ptr().

  { return cast_int<dof_id_type>(_nodes.size()); }

n_nodes_on_proc()

dof_id_type libMesh::MeshBase::n_nodes_on_proc ( const processor_id_type  proc ) const

inherited

Returns

The number of nodes on processor proc.

Definition at line 319 of file mesh_base.C.

References libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::pid_nodes_begin(), and libMesh::MeshBase::pid_nodes_end().

Referenced by libMesh::MeshBase::n_local_nodes(), and libMesh::MeshBase::n_unpartitioned_nodes().

{
  // We're either counting a processor's nodes or unpartitioned
  // nodes
  libmesh_assert (proc_id < this->n_processors() ||
                  proc_id == DofObject::invalid_processor_id);

  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
                                                 this->pid_nodes_end  (proc_id)));
}

n_partitions()

unsigned int libMesh::MeshBase::n_partitions ( ) const

inlineinherited

Returns

The number of partitions which have been defined via a call to either mesh.partition() or by building a Partitioner object and calling partition.

Note

The partitioner object is responsible for setting this value.

Definition at line 875 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

Referenced by libMesh::MeshBase::get_info(), libMesh::BoundaryInfo::sync(), libMesh::NameBasedIO::write(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

  { return _n_parts; }

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 95 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::MeshBase::partition(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

  { return cast_int<processor_id_type>(_communicator.size()); }

n_sub_elem()

dof_id_type libMesh::MeshBase::n_sub_elem ( ) const

inherited

Returns

The number of elements that will be written out in certain I/O formats.

For example, a 9-noded quadrilateral will be broken into 4 linear sub-elements for plotting purposes. Thus, for a mesh of 2 QUAD9 elements n_tecplot_elem() will return 8. Implemented in terms of element_iterators.

Definition at line 354 of file mesh_base.C.

References libMesh::MeshBase::elem(), libMesh::MeshBase::element_ptr_range(), and libMesh::Elem::n_sub_elem().

{
  dof_id_type ne=0;

  for (const auto & elem : this->element_ptr_range())
    ne += elem->n_sub_elem();

  return ne;
}

n_subdomains()

subdomain_id_type libMesh::MeshBase::n_subdomains ( ) const

inherited

Returns

The number of subdomains in the global mesh. Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Definition at line 304 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

Referenced by libMesh::MeshBase::get_info(), libMesh::XdrIO::write(), and libMesh::NameBasedIO::write_nodal_data().

{
  // This requires an inspection on every processor
  parallel_object_only();

  std::set<subdomain_id_type> ids;

  this->subdomain_ids (ids);

  return cast_int<subdomain_id_type>(ids.size());
}

n_unpartitioned_elem()

dof_id_type libMesh::MeshBase::n_unpartitioned_elem ( ) const

inlineinherited

Returns

The number of elements owned by no processor.

Definition at line 392 of file mesh_base.h.

References libMesh::DofObject::invalid_processor_id, and libMesh::MeshBase::n_elem_on_proc().

Referenced by libMesh::DistributedMesh::parallel_n_elem(), and libMesh::MeshBase::partition().

  { return this->n_elem_on_proc (DofObject::invalid_processor_id); }

n_unpartitioned_nodes()

dof_id_type libMesh::MeshBase::n_unpartitioned_nodes ( ) const

inlineinherited

Returns

The number of nodes owned by no processor.

Definition at line 292 of file mesh_base.h.

References libMesh::DofObject::invalid_processor_id, and libMesh::MeshBase::n_nodes_on_proc().

Referenced by libMesh::DistributedMesh::parallel_n_nodes().

  { return this->n_nodes_on_proc (DofObject::invalid_processor_id); }

next_unique_id()

unique_id_type libMesh::MeshBase::next_unique_id ( )

inlineinherited

Returns

The next unique id to be used.

Definition at line 305 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

{ return _next_unique_id; }

node() [1/2]

virtual const Node& libMesh::MeshBase::node ( const dof_id_type  i ) const

inlinevirtualinherited

Returns

A constant reference (for reading only) to the node, which should be present in this processor's subset of the mesh data structure.

Deprecated:

Use the less confusingly-named node_ref() instead.

Definition at line 454 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshBase::cache_elem_dims(), clear(), libMesh::DistributedMesh::clear(), and renumber_nodes_and_elements().

  {
    libmesh_deprecated();
    return *this->node_ptr(i);
  }

node() [2/2]

virtual Node& libMesh::MeshBase::node ( const dof_id_type  i )

inlinevirtualinherited

Returns

A reference to the node, which should be present in this processor's subset of the mesh data structure.

Deprecated:

Use the less confusingly-named node_ref() instead.

Definition at line 468 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

  {
    libmesh_deprecated();
    return *this->node_ptr(i);
  }

node_ptr() [1/2]

const Node * libMesh::ReplicatedMesh::node_ptr ( const dof_id_type  i ) const

overridevirtual

Returns

A pointer to the node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 169 of file replicated_mesh.C.

References _nodes, and n_nodes().

Referenced by stitching_helper().

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i); // This will change soon

  return _nodes[i];
}

node_ptr() [2/2]

Node * libMesh::ReplicatedMesh::node_ptr ( const dof_id_type  i )

overridevirtual

Returns

A writable pointer to the node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 181 of file replicated_mesh.C.

References _nodes, and n_nodes().

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i); // This will change soon

  return _nodes[i];
}

node_ptr_range() [1/2]

virtual SimpleRange<node_iterator> libMesh::ReplicatedMesh::node_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 420 of file replicated_mesh.h.

References nodes_begin(), and nodes_end().

{ return {nodes_begin(), nodes_end()}; }

node_ptr_range() [2/2]

virtual SimpleRange<const_node_iterator> libMesh::ReplicatedMesh::node_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 421 of file replicated_mesh.h.

References nodes_begin(), and nodes_end().

{ return {nodes_begin(), nodes_end()}; }

node_ref() [1/2]

virtual const Node& libMesh::MeshBase::node_ref ( const dof_id_type  i ) const

inlinevirtualinherited

Returns

A constant reference (for reading only) to the node, which should be present in this processor's subset of the mesh data structure.

Definition at line 434 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::SyncNodalPositions::act_on_data(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::correct_node_proc_ids(), point(), libMesh::DistributedMesh::point(), libMesh::XdrIO::read_serialized_nodes(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), stitching_helper(), and libMesh::GmshIO::write_mesh().

                                                            {
    return *this->node_ptr(i);
  }

node_ref() [2/2]

virtual Node& libMesh::MeshBase::node_ref ( const dof_id_type  i )

inlinevirtualinherited

Returns

A reference to the node, which should be present in this processor's subset of the mesh data structure.

Definition at line 442 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

                                                {
    return *this->node_ptr(i);
  }

nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::nodes_begin ( )

overridevirtual

Node iterator accessor functions.

Implements libMesh::MeshBase.

Referenced by node_ptr_range().

nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by node_ptr_range().

nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_active_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_active_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_active_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_active_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_ancestor_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_ancestor_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_ancestor_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_ancestor_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_subactive_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_subactive_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::not_subactive_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::not_subactive_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

operator=() [1/2]

ReplicatedMesh& libMesh::ReplicatedMesh::operator= ( const ReplicatedMesh &  )

delete

Copy and move assignment are not allowed.

operator=() [2/2]

ReplicatedMesh& libMesh::ReplicatedMesh::operator= ( ReplicatedMesh &&  )

delete

own_node()

virtual void libMesh::MeshBase::own_node ( Node &  )

inlinevirtualinherited

Takes ownership of node n on this partition of a distributed mesh, by setting n.processor_id() to this->processor_id(), as well as changing n.id() and moving it in the mesh's internal container to give it a new authoritative id.

Reimplemented in libMesh::DistributedMesh.

Definition at line 639 of file mesh_base.h.

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

{}

parallel_max_unique_id()

unique_id_type libMesh::ReplicatedMesh::parallel_max_unique_id ( ) const

overridevirtual

Returns

A number greater than or equal to the maximum unique_id in the mesh.

Implements libMesh::MeshBase.

Definition at line 592 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, libMesh::ParallelObject::comm(), and libMesh::Parallel::Communicator::max().

Referenced by stitching_helper(), and update_parallel_id_counts().

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

  unique_id_type max_local = _next_unique_id;
  this->comm().max(max_local);
  return max_local;
}

parallel_n_elem()

virtual dof_id_type libMesh::ReplicatedMesh::parallel_n_elem ( ) const

inlineoverridevirtual

Returns

The number of elements in the mesh.

The parallel_n_elem() function computes a parallel-synchronized value on distributed meshes, and so must be called in parallel only.

Implements libMesh::MeshBase.

Definition at line 118 of file replicated_mesh.h.

References _elements.

  { return cast_int<dof_id_type>(_elements.size()); }

parallel_n_nodes()

virtual dof_id_type libMesh::ReplicatedMesh::parallel_n_nodes ( ) const

inlineoverridevirtual

Returns

The number of nodes in the mesh.

This function and others must be overridden in derived classes since the MeshBase class has no specific storage for nodes or elements. The parallel_n_nodes() function computes a parallel-synchronized value on distributed meshes, and so must be called in parallel only.

Implements libMesh::MeshBase.

Definition at line 106 of file replicated_mesh.h.

References _nodes.

  { return cast_int<dof_id_type>(_nodes.size()); }

partition() [1/2]

void libMesh::MeshBase::partition ( const unsigned int  n_parts )

virtualinherited

Call the default partitioner (currently metis_partition()).

Definition at line 426 of file mesh_base.C.

References libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::is_serial(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::partitioner(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshBase::skip_partitioning(), and libMesh::MeshBase::update_post_partitioning().

Referenced by libMesh::split_mesh().

{
  // If we get here and we have unpartitioned elements, we need that
  // fixed.
  if (this->n_unpartitioned_elem() > 0)
    {
      libmesh_assert (partitioner().get());
      libmesh_assert (this->is_serial());
      partitioner()->partition (*this, n_parts);
    }
  // A nullptr partitioner means don't repartition; skip_partitioning()
  // checks on this.
  // Non-serial meshes may not be ready for repartitioning here.
  else if (!skip_partitioning())
    {
      partitioner()->partition (*this, n_parts);
    }
  else
    {
      // Adaptive coarsening may have "orphaned" nodes on processors
      // whose elements no longer share them.  We need to check for
      // and possibly fix that.
      MeshTools::correct_node_proc_ids(*this);

      // Make sure locally cached partition count is correct
      this->recalculate_n_partitions();

      // Make sure any other locally cached data is correct
      this->update_post_partitioning();
    }
}

partition() [2/2]

void libMesh::MeshBase::partition ( )

inlineinherited

Definition at line 749 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

Referenced by libMesh::MeshBase::prepare_for_use().

  { this->partition(this->n_processors()); }

partitioner()

virtual std::unique_ptr<Partitioner>& libMesh::MeshBase::partitioner ( )

inlinevirtualinherited

A partitioner to use at each prepare_for_use()

Definition at line 126 of file mesh_base.h.

References libMesh::MeshBase::_partitioner.

Referenced by libMesh::MeshBase::partition(), and libMesh::BoundaryInfo::sync().

{ return _partitioner; }

pid_elements_begin() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::pid_elements_begin ( processor_id_type  proc_id )

overridevirtual

Iterate over all elements with a specified processor id.

Implements libMesh::MeshBase.

pid_elements_begin() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::pid_elements_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_elements_end() [1/2]

virtual element_iterator libMesh::ReplicatedMesh::pid_elements_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

pid_elements_end() [2/2]

virtual const_element_iterator libMesh::ReplicatedMesh::pid_elements_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_begin() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::pid_nodes_begin ( processor_id_type  proc_id )

overridevirtual

Iterate over nodes with processor_id() == proc_id

Implements libMesh::MeshBase.

pid_nodes_begin() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::pid_nodes_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_end() [1/2]

virtual node_iterator libMesh::ReplicatedMesh::pid_nodes_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_end() [2/2]

virtual const_node_iterator libMesh::ReplicatedMesh::pid_nodes_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

point()

const Point & libMesh::ReplicatedMesh::point ( const dof_id_type  i ) const

overridevirtual

Returns

A constant reference (for reading only) to the point, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 161 of file replicated_mesh.C.

References libMesh::MeshBase::node_ref().

Referenced by stitching_helper().

{
  return this->node_ref(i);
}

point_locator()

const PointLocatorBase & libMesh::MeshBase::point_locator ( ) const

inherited

Returns

A pointer to a PointLocatorBase object for this mesh, constructing a master PointLocator first if necessary.

Deprecated:

This should never be used in threaded or non-parallel_only code.

Definition at line 479 of file mesh_base.C.

References libMesh::MeshBase::_point_locator, libMesh::PointLocatorBase::build(), libMesh::Threads::in_threads, and libMesh::TREE_ELEMENTS.

{
  libmesh_deprecated();

  if (_point_locator.get() == nullptr)
    {
      // PointLocator construction may not be safe within threads
      libmesh_assert(!Threads::in_threads);

      _point_locator = PointLocatorBase::build(TREE_ELEMENTS, *this);
    }

  return *_point_locator;
}

prepare_for_use()

void libMesh::MeshBase::prepare_for_use ( const bool  skip_renumber_nodes_and_elements = false, const bool  skip_find_neighbors = false  )

inherited

Prepare a newly created (or read) mesh for use. This involves 4 steps: 1.) call find_neighbors() 2.) call partition() 3.) call renumber_nodes_and_elements() 4.) call cache_elem_dims()

The argument to skip renumbering is now deprecated - to prevent a mesh from being renumbered, set allow_renumbering(false).

If this is a distributed mesh, local copies of remote elements will be deleted here - to keep those elements replicated during preparation, set allow_remote_element_removal(false).

Definition at line 152 of file mesh_base.C.

References libMesh::MeshBase::_allow_remote_element_removal, libMesh::MeshBase::_ghosting_functors, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::allow_renumbering(), libMesh::MeshBase::cache_elem_dims(), libMesh::MeshBase::clear_point_locator(), libMesh::ParallelObject::comm(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::MeshBase::find_neighbors(), libMesh::MeshBase::is_serial(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshBase::partition(), libMesh::MeshBase::renumber_nodes_and_elements(), and libMesh::MeshBase::update_parallel_id_counts().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshRefinement::coarsen_elements(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::GMVIO::read(), libMesh::UnstructuredMesh::read(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), stitching_helper(), libMesh::BoundaryInfo::sync(), libMesh::TriangleInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::MeshRefinement::uniformly_refine().

{
  LOG_SCOPE("prepare_for_use()", "MeshBase");

  parallel_object_only();

  libmesh_assert(this->comm().verify(this->is_serial()));

  // A distributed mesh may have processors with no elements (or
  // processors with no elements of higher dimension, if we ever
  // support mixed-dimension meshes), but we want consistent
  // mesh_dimension anyways.
  //
  // cache_elem_dims() should get the elem_dimensions() and
  // mesh_dimension() correct later, and we don't need it earlier.


  // Renumber the nodes and elements so that they in contiguous
  // blocks.  By default, _skip_renumber_nodes_and_elements is false.
  //
  // We may currently change that by passing
  // skip_renumber_nodes_and_elements==true to this function, but we
  // should use the allow_renumbering() accessor instead.
  //
  // Instances where you if prepare_for_use() should not renumber the nodes
  // and elements include reading in e.g. an xda/r or gmv file. In
  // this case, the ordering of the nodes may depend on an accompanying
  // solution, and the node ordering cannot be changed.

  if (skip_renumber_nodes_and_elements)
    {
      libmesh_deprecated();
      this->allow_renumbering(false);
    }

  // Mesh modification operations might not leave us with consistent
  // id counts, but our partitioner might need that consistency.
  if (!_skip_renumber_nodes_and_elements)
    this->renumber_nodes_and_elements();
  else
    this->update_parallel_id_counts();

  // Let all the elements find their neighbors
  if (!skip_find_neighbors)
    this->find_neighbors();

  // The user may have set boundary conditions.  We require that the
  // boundary conditions were set consistently.  Because we examine
  // neighbors when evaluating non-raw boundary condition IDs, this
  // assert is only valid when our neighbor links are in place.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
#endif

  // Search the mesh for all the dimensions of the elements
  // and cache them.
  this->cache_elem_dims();

  // Search the mesh for elements that have a neighboring element
  // of dim+1 and set that element as the interior parent
  this->detect_interior_parents();

  // Fix up node unique ids in case mesh generation code didn't take
  // exceptional care to do so.
  //  MeshCommunication().make_node_unique_ids_parallel_consistent(*this);

  // We're going to still require that mesh generation code gets
  // element unique ids consistent.
#if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif

  // Reset our PointLocator.  Any old locator is invalidated any time
  // the elements in the underlying elements in the mesh have changed,
  // so we clear it here.
  this->clear_point_locator();

  // Allow our GhostingFunctor objects to reinit if necessary.
  // Do this before partitioning and redistributing, and before
  // deleting remote elements.
  for (auto & gf : _ghosting_functors)
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }

  // Partition the mesh.
  this->partition();

  // If we're using DistributedMesh, we'll probably want it
  // parallelized.
  if (this->_allow_remote_element_removal)
    this->delete_remote_elements();

  if (!_skip_renumber_nodes_and_elements)
    this->renumber_nodes_and_elements();

  // The mesh is now prepared for use.
  _is_prepared = true;

#if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif
}

print_info()

void libMesh::MeshBase::print_info ( std::ostream &  os = libMesh::out ) const

inherited

Prints relevant information about the mesh.

Definition at line 412 of file mesh_base.C.

References libMesh::MeshBase::get_info().

Referenced by libMesh::InfElemBuilder::build_inf_elem(), and libMesh::operator<<().

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

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< T >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

  { return cast_int<processor_id_type>(_communicator.rank()); }

query_elem() [1/2]

virtual const Elem* libMesh::MeshBase::query_elem ( const dof_id_type  i ) const

inlinevirtualinherited

Returns

A pointer to the element, or nullptr if no such element exists in this processor's mesh data structure.

Deprecated:

Use the less confusingly-named query_elem_ptr() instead.

Definition at line 578 of file mesh_base.h.

References libMesh::MeshBase::query_elem_ptr().

  {
    libmesh_deprecated();
    return this->query_elem_ptr(i);
  }

query_elem() [2/2]

virtual Elem* libMesh::MeshBase::query_elem ( const dof_id_type  i )

inlinevirtualinherited

Returns

A writable pointer to the element, or nullptr if no such element exists in this processor's mesh data structure.

Deprecated:

Use the less confusingly-named query_elem_ptr() instead.

Definition at line 592 of file mesh_base.h.

References libMesh::MeshBase::query_elem_ptr().

  {
    libmesh_deprecated();
    return this->query_elem_ptr(i);
  }

query_elem_ptr() [1/2]

const Elem * libMesh::ReplicatedMesh::query_elem_ptr ( const