libMesh::Mesh Class Reference

Manages a collection of Nodes and Elems. More...

#include <mesh.h>

Inheritance diagram for libMesh::Mesh:

Public Types

typedef Predicates::multi_predicate Predicate
 

Public Member Functions

 Mesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
 
 Mesh (unsigned char dim=1)
 
 Mesh (const UnstructuredMesh &other_mesh)
 
 ~Mesh ()
 
virtual UniquePtr< MeshBaseclone () const libmesh_override
 
virtual void clear () libmesh_override
 
virtual void redistribute () libmesh_override
 
virtual void update_post_partitioning () libmesh_override
 
virtual bool is_serial () const libmesh_override
 
virtual bool is_serial_on_zero () const libmesh_override
 
virtual void set_distributed () libmesh_override
 
virtual bool is_replicated () const libmesh_override
 
template<typename T >
void libmesh_assert_valid_parallel_object_ids (const mapvector< T *, dof_id_type > &) const
 
virtual void libmesh_assert_valid_parallel_ids () const libmesh_override
 
void libmesh_assert_valid_parallel_p_levels () const
 
void libmesh_assert_valid_parallel_flags () const
 
template<typename T >
dof_id_type renumber_dof_objects (mapvector< T *, dof_id_type > &)
 
virtual void renumber_nodes_and_elements () libmesh_override
 
virtual void allgather () libmesh_override
 
virtual void gather_to_zero () libmesh_override
 
virtual void delete_remote_elements () libmesh_override
 
virtual void add_extra_ghost_elem (Elem *e)
 
virtual void clear_extra_ghost_elems ()
 
virtual dof_id_type n_nodes () const libmesh_override
 
virtual dof_id_type max_node_id () const libmesh_override
 
virtual void reserve_nodes (const dof_id_type) libmesh_override
 
virtual dof_id_type n_elem () const libmesh_override
 
virtual dof_id_type n_active_elem () const libmesh_override
 
virtual dof_id_type max_elem_id () const libmesh_override
 
virtual void reserve_elem (const dof_id_type) libmesh_override
 
virtual void update_parallel_id_counts () libmesh_override
 
virtual dof_id_type parallel_n_nodes () const libmesh_override
 
dof_id_type parallel_max_node_id () const
 
virtual dof_id_type parallel_n_elem () const libmesh_override
 
dof_id_type parallel_max_elem_id () const
 
virtual unique_id_type parallel_max_unique_id () const libmesh_override
 
virtual const Pointpoint (const dof_id_type i) const libmesh_override
 
virtual const Nodenode_ptr (const dof_id_type i) const libmesh_override
 
virtual Nodenode_ptr (const dof_id_type i) libmesh_override
 
virtual const Nodequery_node_ptr (const dof_id_type i) const libmesh_override
 
virtual Nodequery_node_ptr (const dof_id_type i) libmesh_override
 
virtual const Elemelem_ptr (const dof_id_type i) const libmesh_override
 
virtual Elemelem_ptr (const dof_id_type i) libmesh_override
 
virtual const Elemquery_elem_ptr (const dof_id_type i) const libmesh_override
 
virtual Elemquery_elem_ptr (const dof_id_type i) libmesh_override
 
virtual Nodeadd_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id) libmesh_override
 
virtual Nodeadd_node (Node *n) libmesh_override
 
virtual Nodeinsert_node (Node *n) libmesh_override
 
virtual void delete_node (Node *n) libmesh_override
 
virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) libmesh_override
 
virtual Elemadd_elem (Elem *e) libmesh_override
 
virtual Eleminsert_elem (Elem *e) libmesh_override
 
virtual void delete_elem (Elem *e) libmesh_override
 
virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) libmesh_override
 
virtual void fix_broken_node_and_element_numbering () libmesh_override
 
virtual element_iterator elements_begin () libmesh_override
 
virtual const_element_iterator elements_begin () const libmesh_override
 
virtual element_iterator elements_end () libmesh_override
 
virtual const_element_iterator elements_end () const libmesh_override
 
virtual element_iterator active_elements_begin () libmesh_override
 
virtual const_element_iterator active_elements_begin () const libmesh_override
 
virtual element_iterator active_elements_end () libmesh_override
 
virtual const_element_iterator active_elements_end () const libmesh_override
 
virtual element_iterator ancestor_elements_begin () libmesh_override
 
virtual const_element_iterator ancestor_elements_begin () const libmesh_override
 
virtual element_iterator ancestor_elements_end () libmesh_override
 
virtual const_element_iterator ancestor_elements_end () const libmesh_override
 
virtual element_iterator subactive_elements_begin () libmesh_override
 
virtual const_element_iterator subactive_elements_begin () const libmesh_override
 
virtual element_iterator subactive_elements_end () libmesh_override
 
virtual const_element_iterator subactive_elements_end () const libmesh_override
 
virtual element_iterator not_active_elements_begin () libmesh_override
 
virtual const_element_iterator not_active_elements_begin () const libmesh_override
 
virtual element_iterator not_active_elements_end () libmesh_override
 
virtual const_element_iterator not_active_elements_end () const libmesh_override
 
virtual element_iterator not_ancestor_elements_begin () libmesh_override
 
virtual const_element_iterator not_ancestor_elements_begin () const libmesh_override
 
virtual element_iterator not_ancestor_elements_end () libmesh_override
 
virtual const_element_iterator not_ancestor_elements_end () const libmesh_override
 
virtual element_iterator not_subactive_elements_begin () libmesh_override
 
virtual const_element_iterator not_subactive_elements_begin () const libmesh_override
 
virtual element_iterator not_subactive_elements_end () libmesh_override
 
virtual const_element_iterator not_subactive_elements_end () const libmesh_override
 
virtual element_iterator local_elements_begin () libmesh_override
 
virtual const_element_iterator local_elements_begin () const libmesh_override
 
virtual element_iterator local_elements_end () libmesh_override
 
virtual const_element_iterator local_elements_end () const libmesh_override
 
virtual element_iterator semilocal_elements_begin () libmesh_override
 
virtual const_element_iterator semilocal_elements_begin () const libmesh_override
 
virtual element_iterator semilocal_elements_end () libmesh_override
 
virtual const_element_iterator semilocal_elements_end () const libmesh_override
 
virtual element_iterator active_semilocal_elements_begin () libmesh_override
 
virtual const_element_iterator active_semilocal_elements_begin () const libmesh_override
 
virtual element_iterator active_semilocal_elements_end () libmesh_override
 
virtual const_element_iterator active_semilocal_elements_end () const libmesh_override
 
virtual element_iterator facelocal_elements_begin () libmesh_override
 
virtual const_element_iterator facelocal_elements_begin () const libmesh_override
 
virtual element_iterator facelocal_elements_end () libmesh_override
 
virtual const_element_iterator facelocal_elements_end () const libmesh_override
 
virtual element_iterator not_local_elements_begin () libmesh_override
 
virtual const_element_iterator not_local_elements_begin () const libmesh_override
 
virtual element_iterator not_local_elements_end () libmesh_override
 
virtual const_element_iterator not_local_elements_end () const libmesh_override
 
virtual element_iterator active_local_elements_begin () libmesh_override
 
virtual const_element_iterator active_local_elements_begin () const libmesh_override
 
virtual element_iterator active_local_elements_end () libmesh_override
 
virtual const_element_iterator active_local_elements_end () const libmesh_override
 
virtual element_iterator active_not_local_elements_begin () libmesh_override
 
virtual const_element_iterator active_not_local_elements_begin () const libmesh_override
 
virtual element_iterator active_not_local_elements_end () libmesh_override
 
virtual const_element_iterator active_not_local_elements_end () const libmesh_override
 
virtual element_iterator level_elements_begin (unsigned int level) libmesh_override
 
virtual const_element_iterator level_elements_begin (unsigned int level) const libmesh_override
 
virtual element_iterator level_elements_end (unsigned int level) libmesh_override
 
virtual const_element_iterator level_elements_end (unsigned int level) const libmesh_override
 
virtual element_iterator not_level_elements_begin (unsigned int level) libmesh_override
 
virtual const_element_iterator not_level_elements_begin (unsigned int level) const libmesh_override
 
virtual element_iterator not_level_elements_end (unsigned int level) libmesh_override
 
virtual const_element_iterator not_level_elements_end (unsigned int level) const libmesh_override
 
virtual element_iterator local_level_elements_begin (unsigned int level) libmesh_override
 
virtual const_element_iterator local_level_elements_begin (unsigned int level) const libmesh_override
 
virtual element_iterator local_level_elements_end (unsigned int level) libmesh_override
 
virtual const_element_iterator local_level_elements_end (unsigned int level) const libmesh_override
 
virtual element_iterator local_not_level_elements_begin (unsigned int level) libmesh_override
 
virtual const_element_iterator local_not_level_elements_begin (unsigned int level) const libmesh_override
 
virtual element_iterator local_not_level_elements_end (unsigned int level) libmesh_override
 
virtual const_element_iterator local_not_level_elements_end (unsigned int level) const libmesh_override
 
virtual element_iterator pid_elements_begin (processor_id_type proc_id) libmesh_override
 
virtual const_element_iterator pid_elements_begin (processor_id_type proc_id) const libmesh_override
 
virtual element_iterator pid_elements_end (processor_id_type proc_id) libmesh_override
 
virtual const_element_iterator pid_elements_end (processor_id_type proc_id) const libmesh_override
 
virtual element_iterator type_elements_begin (ElemType type) libmesh_override
 
virtual const_element_iterator type_elements_begin (ElemType type) const libmesh_override
 
virtual element_iterator type_elements_end (ElemType type) libmesh_override
 
virtual const_element_iterator type_elements_end (ElemType type) const libmesh_override
 
virtual element_iterator active_type_elements_begin (ElemType type) libmesh_override
 
virtual const_element_iterator active_type_elements_begin (ElemType type) const libmesh_override
 
virtual element_iterator active_type_elements_end (ElemType type) libmesh_override
 
virtual const_element_iterator active_type_elements_end (ElemType type) const libmesh_override
 
virtual element_iterator active_pid_elements_begin (processor_id_type proc_id) libmesh_override
 
virtual const_element_iterator active_pid_elements_begin (processor_id_type proc_id) const libmesh_override
 
virtual element_iterator active_pid_elements_end (processor_id_type proc_id) libmesh_override
 
virtual const_element_iterator active_pid_elements_end (processor_id_type proc_id) const libmesh_override
 
virtual element_iterator unpartitioned_elements_begin () libmesh_override
 
virtual const_element_iterator unpartitioned_elements_begin () const libmesh_override
 
virtual element_iterator unpartitioned_elements_end () libmesh_override
 
virtual const_element_iterator unpartitioned_elements_end () const libmesh_override
 
virtual element_iterator active_unpartitioned_elements_begin () libmesh_override
 
virtual const_element_iterator active_unpartitioned_elements_begin () const libmesh_override
 
virtual element_iterator active_unpartitioned_elements_end () libmesh_override
 
virtual const_element_iterator active_unpartitioned_elements_end () const libmesh_override
 
virtual element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) libmesh_override
 
virtual const_element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const libmesh_override
 
virtual element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) libmesh_override
 
virtual const_element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const libmesh_override
 
virtual element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) libmesh_override
 
virtual const_element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) const libmesh_override
 
virtual element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) libmesh_override
 
virtual const_element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) const libmesh_override
 
virtual element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) libmesh_override
 
virtual const_element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) const libmesh_override
 
virtual element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) libmesh_override
 
virtual const_element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) const libmesh_override
 
virtual element_iterator ghost_elements_begin () libmesh_override
 
virtual const_element_iterator ghost_elements_begin () const libmesh_override
 
virtual element_iterator ghost_elements_end () libmesh_override
 
virtual const_element_iterator ghost_elements_end () const libmesh_override
 
virtual element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) libmesh_override
 
virtual const_element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const libmesh_override
 
virtual element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) libmesh_override
 
virtual const_element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const libmesh_override
 
virtual element_iterator flagged_elements_begin (unsigned char rflag) libmesh_override
 
virtual const_element_iterator flagged_elements_begin (unsigned char rflag) const libmesh_override
 
virtual element_iterator flagged_elements_end (unsigned char rflag) libmesh_override
 
virtual const_element_iterator flagged_elements_end (unsigned char rflag) const libmesh_override
 
virtual element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) libmesh_override
 
virtual const_element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) const libmesh_override
 
virtual element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) libmesh_override
 
virtual const_element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) const libmesh_override
 
virtual node_iterator nodes_begin () libmesh_override
 
virtual const_node_iterator nodes_begin () const libmesh_override
 
virtual node_iterator nodes_end () libmesh_override
 
virtual const_node_iterator nodes_end () const libmesh_override
 
virtual node_iterator active_nodes_begin () libmesh_override
 
virtual const_node_iterator active_nodes_begin () const libmesh_override
 
virtual node_iterator active_nodes_end () libmesh_override
 
virtual const_node_iterator active_nodes_end () const libmesh_override
 
virtual node_iterator local_nodes_begin () libmesh_override
 
virtual const_node_iterator local_nodes_begin () const libmesh_override
 
virtual node_iterator local_nodes_end () libmesh_override
 
virtual const_node_iterator local_nodes_end () const libmesh_override
 
virtual node_iterator pid_nodes_begin (processor_id_type proc_id) libmesh_override
 
virtual const_node_iterator pid_nodes_begin (processor_id_type proc_id) const libmesh_override
 
virtual node_iterator pid_nodes_end (processor_id_type proc_id) libmesh_override
 
virtual const_node_iterator pid_nodes_end (processor_id_type proc_id) const libmesh_override
 
virtual node_iterator bid_nodes_begin (boundary_id_type bndry_id) libmesh_override
 
virtual const_node_iterator bid_nodes_begin (boundary_id_type bndry_id) const libmesh_override
 
virtual node_iterator bid_nodes_end (boundary_id_type bndry_id) libmesh_override
 
virtual const_node_iterator bid_nodes_end (boundary_id_type bndry_id) const libmesh_override
 
virtual node_iterator bnd_nodes_begin () libmesh_override
 
virtual const_node_iterator bnd_nodes_begin () const libmesh_override
 
virtual node_iterator bnd_nodes_end () libmesh_override
 
virtual const_node_iterator bnd_nodes_end () const libmesh_override
 
virtual node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) libmesh_override
 
virtual const_node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const libmesh_override
 
virtual node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) libmesh_override
 
virtual const_node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const libmesh_override
 
virtual void read (const std::string &name, void *mesh_data=libmesh_nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) libmesh_override
 
virtual void write (const std::string &name) libmesh_override
 
void write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names)
 
virtual void all_first_order () libmesh_override
 
virtual void all_second_order (const bool full_ordered=true) libmesh_override
 
void create_pid_mesh (UnstructuredMesh &pid_mesh, const processor_id_type pid) const
 
void create_submesh (UnstructuredMesh &new_mesh, 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)
 
virtual void find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) libmesh_override
 
virtual bool contract () libmesh_override
 
virtual UniquePtr< Partitioner > & partitioner ()
 
const BoundaryInfoget_boundary_info () const
 
BoundaryInfoget_boundary_info ()
 
bool is_prepared () const
 
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 Nodenode_ref (const dof_id_type i) const
 
virtual Nodenode_ref (const dof_id_type i)
 
virtual const Nodenode (const dof_id_type i) const
 
virtual Nodenode (const dof_id_type i)
 
virtual const Elemelem_ref (const dof_id_type i) const
 
virtual Elemelem_ref (const dof_id_type i)
 
virtual const Elemelem (const dof_id_type i) const
 
virtual Elemelem (const dof_id_type i)
 
virtual const Elemquery_elem (const dof_id_type i) const
 
virtual Elemquery_elem (const dof_id_type i)
 
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 ()
 
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
 
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 PointLocatorBasepoint_locator () const
 
UniquePtr< PointLocatorBasesub_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
 
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::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Public Attributes

UniquePtr< BoundaryInfoboundary_info
 

Protected Member Functions

unsigned int & set_n_partitions ()
 

Protected Attributes

mapvector< Node *, dof_id_type_nodes
 
mapvector< Elem *, dof_id_type_elements
 
bool _is_serial
 
bool _is_serial_on_proc_0
 
dof_id_type _n_nodes
 
dof_id_type _n_elem
 
dof_id_type _max_node_id
 
dof_id_type _max_elem_id
 
dof_id_type _next_free_local_node_id
 
dof_id_type _next_free_local_elem_id
 
dof_id_type _next_free_unpartitioned_node_id
 
dof_id_type _next_free_unpartitioned_elem_id
 
unique_id_type _next_unpartitioned_unique_id
 
std::set< Elem * > _extra_ghost_elems
 
unsigned int _n_parts
 
bool _is_prepared
 
UniquePtr< PointLocatorBase_point_locator
 
bool _count_lower_dim_elems_in_point_locator
 
UniquePtr< 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
 
UniquePtr< GhostingFunctor_default_ghosting
 
std::set< GhostingFunctor * > _ghosting_functors
 
const Parallel::Communicator_communicator
 

Detailed Description

Manages a collection of Nodes and Elems.

The Mesh class is a thin wrapper, around the ReplicatedMesh class by default.

Author
Benjamin S. Kirk
Date
2002

Definition at line 50 of file mesh.h.

Member Typedef Documentation

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

Definition at line 874 of file mesh_base.h.

Constructor & Destructor Documentation

libMesh::Mesh::Mesh ( const Parallel::Communicator comm_in,
unsigned char  dim = 1 
)
inlineexplicit

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 60 of file mesh.h.

62  : DefaultMesh(comm_in,dim) {}
DistributedMesh DefaultMesh
Definition: mesh.h:27
libMesh::Mesh::Mesh ( unsigned char  dim = 1)
inlineexplicit

Deprecated 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 71 of file mesh.h.

72  : DefaultMesh(dim) {}
DistributedMesh DefaultMesh
Definition: mesh.h:27
libMesh::Mesh::Mesh ( const UnstructuredMesh other_mesh)
inline

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

Definition at line 79 of file mesh.h.

79 : DefaultMesh(other_mesh) {}
DistributedMesh DefaultMesh
Definition: mesh.h:27
libMesh::Mesh::~Mesh ( )
inline

Destructor.

Definition at line 84 of file mesh.h.

84 {}

Member Function Documentation

virtual element_iterator libMesh::DistributedMesh::active_elements_begin ( )
virtualinherited

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 libMesh::DistributedMesh::reserve_elem().

virtual const_element_iterator libMesh::DistributedMesh::active_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_local_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_local_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::active_nodes_begin ( )
virtualinherited

Iterate over only the active nodes in the Mesh.

Implements libMesh::MeshBase.

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

virtual const_node_iterator libMesh::DistributedMesh::active_nodes_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::active_nodes_end ( )
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::active_nodes_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type ss)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type ss) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type ss)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type ss) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_begin ( )
virtualinherited

Iterate over active unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

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

virtual const_element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

Elem * libMesh::DistributedMesh::add_elem ( Elem e)
virtualinherited

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 409 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_next_free_local_elem_id, libMesh::DistributedMesh::_next_free_unpartitioned_elem_id, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), std::max(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::DistributedMesh::add_extra_ghost_elem(), and libMesh::DistributedMesh::reserve_elem().

410 {
411  // Don't try to add NULLs!
412  libmesh_assert(e);
413 
414  // Trying to add an existing element is a no-op
415  if (e->valid_id() && _elements[e->id()] == e)
416  return e;
417 
418  const processor_id_type elem_procid = e->processor_id();
419 
420  if (!e->valid_id())
421  {
422  // We should only be creating new ids past the end of the range
423  // of existing ids
424  libmesh_assert_greater_equal(_next_free_unpartitioned_elem_id,
425  _max_elem_id);
426  libmesh_assert_greater_equal(_next_free_local_elem_id, _max_elem_id);
427 
428  // Use the unpartitioned ids for unpartitioned elems, and
429  // temporarily for ghost elems
431  if (elem_procid == this->processor_id())
432  next_id = &_next_free_local_elem_id;
433  e->set_id (*next_id);
434  }
435 
436  {
437  // Advance next_ids up high enough that each is pointing to an
438  // unused id and any subsequent increments will still point us
439  // to unused ids
441  static_cast<dof_id_type>(e->id()+1));
442 
445  ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
446  (this->n_processors() + 1) + this->n_processors();
449  ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
450  (this->n_processors() + 1) + this->processor_id();
451 
452 #ifndef NDEBUG
453  // We need a const mapvector so we don't inadvertently create
454  // NULL entries when testing for non-NULL ones
455  const mapvector<Elem *, dof_id_type> & const_elements = _elements;
456 #endif
458  libmesh_assert(!const_elements[_next_free_local_elem_id]);
459  }
460 
461  // Don't try to overwrite existing elems
462  libmesh_assert (!_elements[e->id()]);
463 
464  _elements[e->id()] = e;
465 
466  // Try to make the cached elem data more accurate
467  if (elem_procid == this->processor_id() ||
468  elem_procid == DofObject::invalid_processor_id)
469  _n_elem++;
470 
471 #ifdef LIBMESH_ENABLE_UNIQUE_ID
472  if (!e->valid_unique_id())
473  {
474  if (processor_id() == e->processor_id())
475  {
476  e->set_unique_id() = _next_unique_id;
477  _next_unique_id += this->n_processors() + 1;
478  }
479  else
480  {
481  e->set_unique_id() = _next_unpartitioned_unique_id;
483  }
484  }
485 #endif
486 
487  // Unpartitioned elems should be added on every processor
488  // And shouldn't be added in the same batch as ghost elems
489  // But we might be just adding on processor 0 to
490  // broadcast later
491  // #ifdef DEBUG
492  // if (elem_procid == DofObject::invalid_processor_id)
493  // {
494  // dof_id_type elem_id = e->id();
495  // this->comm().max(elem_id);
496  // libmesh_assert_equal_to (elem_id, e->id());
497  // }
498  // #endif
499 
500  return e;
501 }
mapvector< Elem *, dof_id_type > _elements
processor_id_type n_processors() const
uint8_t processor_id_type
Definition: id_types.h:99
long double max(long double a, double b)
libmesh_assert(j)
unique_id_type _next_unique_id
Definition: mesh_base.h:1349
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
dof_id_type _next_free_unpartitioned_elem_id
unique_id_type _next_unpartitioned_unique_id
dof_id_type _next_free_local_elem_id
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::DistributedMesh::add_extra_ghost_elem ( Elem e)
virtualinherited

Inserts the element and adds it to a list of elements that should not get deleted or have their descendants deleted by delete_remote_elements. This is handy for inserting otherwise off-processor elements that you want to keep track of on this processor.

Definition at line 1423 of file distributed_mesh.C.

References libMesh::DistributedMesh::_extra_ghost_elems, and libMesh::DistributedMesh::add_elem().

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

1424 {
1425  // First add the elem like normal
1426  add_elem(e);
1427 
1428  // Now add it to the set that won't be deleted when we call
1429  // delete_remote_elements()
1430  _extra_ghost_elems.insert(e);
1431 }
std::set< Elem * > _extra_ghost_elems
virtual Elem * add_elem(Elem *e) libmesh_override
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 771 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors, and libMesh::MeshBase::remove_ghosting_functor().

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

772  { _ghosting_functors.insert(&ghosting_functor); }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1406
Node * libMesh::DistributedMesh::add_node ( Node n)
virtualinherited

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 606 of file distributed_mesh.C.

References libMesh::DistributedMesh::_max_node_id, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_next_free_local_node_id, libMesh::DistributedMesh::_next_free_unpartitioned_node_id, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::DistributedMesh::_nodes, libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), std::max(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::DistributedMesh::add_point(), libMesh::DistributedMesh::insert_node(), and libMesh::DistributedMesh::reserve_elem().

607 {
608  // Don't try to add NULLs!
609  libmesh_assert(n);
610 
611  // Trying to add an existing node is a no-op
612  if (n->valid_id() && _nodes[n->id()] == n)
613  return n;
614 
615  const processor_id_type node_procid = n->processor_id();
616 
617  if (!n->valid_id())
618  {
619  // We should only be creating new ids past the end of the range
620  // of existing ids
621  libmesh_assert_greater_equal(_next_free_unpartitioned_node_id,
622  _max_node_id);
623  libmesh_assert_greater_equal(_next_free_local_node_id, _max_node_id);
624 
625  // Use the unpartitioned ids for unpartitioned nodes,
626  // and temporarily for ghost nodes
628  if (node_procid == this->processor_id())
629  next_id = &_next_free_local_node_id;
630  n->set_id (*next_id);
631  }
632 
633  {
634  // Advance next_ids up high enough that each is pointing to an
635  // unused id and any subsequent increments will still point us
636  // to unused ids
638  static_cast<dof_id_type>(n->id()+1));
639 
642  ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
643  (this->n_processors() + 1) + this->n_processors();
646  ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
647  (this->n_processors() + 1) + this->processor_id();
648 
649 #ifndef NDEBUG
650  // We need a const mapvector so we don't inadvertently create
651  // NULL entries when testing for non-NULL ones
652  const mapvector<Node *,dof_id_type> & const_nodes = _nodes;
653 #endif
656  }
657 
658  // Don't try to overwrite existing nodes
659  libmesh_assert (!_nodes[n->id()]);
660 
661  _nodes[n->id()] = n;
662 
663  // Try to make the cached node data more accurate
664  if (node_procid == this->processor_id() ||
665  node_procid == DofObject::invalid_processor_id)
666  _n_nodes++;
667 
668 #ifdef LIBMESH_ENABLE_UNIQUE_ID
669  if (!n->valid_unique_id())
670  {
671  if (processor_id() == n->processor_id())
672  {
673  n->set_unique_id() = _next_unique_id;
674  _next_unique_id += this->n_processors();
675  }
676  else
677  {
678  n->set_unique_id() = _next_unpartitioned_unique_id;
680  }
681  }
682 #endif
683 
684 
685  // Unpartitioned nodes should be added on every processor
686  // And shouldn't be added in the same batch as ghost nodes
687  // But we might be just adding on processor 0 to
688  // broadcast later
689  // #ifdef DEBUG
690  // if (node_procid == DofObject::invalid_processor_id)
691  // {
692  // dof_id_type node_id = n->id();
693  // this->comm().max(node_id);
694  // libmesh_assert_equal_to (node_id, n->id());
695  // }
696  // #endif
697 
698  return n;
699 }
dof_id_type _next_free_local_node_id
processor_id_type n_processors() const
uint8_t processor_id_type
Definition: id_types.h:99
long double max(long double a, double b)
libmesh_assert(j)
unique_id_type _next_unique_id
Definition: mesh_base.h:1349
mapvector< Node *, dof_id_type > _nodes
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
dof_id_type _next_free_unpartitioned_node_id
unique_id_type _next_unpartitioned_unique_id
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:64
Node * libMesh::DistributedMesh::add_point ( const Point p,
const dof_id_type  id = DofObject::invalid_id,
const processor_id_type  proc_id = DofObject::invalid_processor_id 
)
virtualinherited

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 582 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, libMesh::DistributedMesh::add_node(), libMesh::Node::build(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and libMesh::DofObject::processor_id().

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

585 {
586  if (_nodes.count(id))
587  {
588  Node * n = _nodes[id];
589  libmesh_assert (n);
590  libmesh_assert_equal_to (n->id(), id);
591 
592  *n = p;
593  n->processor_id() = proc_id;
594 
595  return n;
596  }
597 
598  Node * n = Node::build(p, id).release();
599  n->processor_id() = proc_id;
600 
601  return DistributedMesh::add_node(n);
602 }
static UniquePtr< Node > build(const Node &n)
Definition: node.h:282
libmesh_assert(j)
virtual Node * add_node(Node *n) libmesh_override
mapvector< Node *, dof_id_type > _nodes
void libMesh::UnstructuredMesh::all_first_order ( )
virtualinherited

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.

Loop over the high-ordered elements. First make sure they are indeed high-order, and then replace them with an equivalent first-order element.

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 303 of file mesh_modification.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::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::libmesh_assert(), libMesh::MeshBase::max_node_id(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), 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(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), and libMesh::Elem::which_child_am_i().

304 {
305  /*
306  * when the mesh is not prepared,
307  * at least renumber the nodes and
308  * elements, so that the node ids
309  * are correct
310  */
311  if (!this->_is_prepared)
313 
314  START_LOG("all_first_order()", "Mesh");
315 
319  std::vector<bool> node_touched_by_me(this->max_node_id(), false);
320 
326  element_iterator endit = elements_end();
327  for (element_iterator it = elements_begin();
328  it != endit; ++it)
329  {
330  Elem * so_elem = *it;
331 
332  libmesh_assert(so_elem);
333 
334  /*
335  * build the first-order equivalent, add to
336  * the new_elements list.
337  */
338  Elem * lo_elem = Elem::build
340  (so_elem->type()), so_elem->parent()).release();
341 
342  for (unsigned int s=0; s != so_elem->n_sides(); ++s)
343  if (so_elem->neighbor_ptr(s) == remote_elem)
344  lo_elem->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
345 
346 #ifdef LIBMESH_ENABLE_AMR
347  /*
348  * Reset the parent links of any child elements
349  */
350  if (so_elem->has_children())
351  for (unsigned int c=0; c != so_elem->n_children(); ++c)
352  {
353  so_elem->child_ptr(c)->set_parent(lo_elem);
354  lo_elem->add_child(so_elem->child_ptr(c), c);
355  }
356 
357  /*
358  * Reset the child link of any parent element
359  */
360  if (so_elem->parent())
361  {
362  unsigned int c =
363  so_elem->parent()->which_child_am_i(so_elem);
364  lo_elem->parent()->replace_child(lo_elem, c);
365  }
366 
367  /*
368  * Copy as much data to the new element as makes sense
369  */
370  lo_elem->set_p_level(so_elem->p_level());
371  lo_elem->set_refinement_flag(so_elem->refinement_flag());
372  lo_elem->set_p_refinement_flag(so_elem->p_refinement_flag());
373 #endif
374 
375  libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());
376 
377  /*
378  * By definition the vertices of the linear and
379  * second order element are identically numbered.
380  * transfer these.
381  */
382  for (unsigned int v=0; v < so_elem->n_vertices(); v++)
383  {
384  lo_elem->set_node(v) = so_elem->node_ptr(v);
385  node_touched_by_me[lo_elem->node_id(v)] = true;
386  }
387 
388  /*
389  * find_neighbors relies on remote_elem neighbor links being
390  * properly maintained.
391  */
392  for (unsigned short s=0; s<so_elem->n_sides(); s++)
393  {
394  if (so_elem->neighbor(s) == remote_elem)
395  lo_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
396  }
397 
405  (this->get_boundary_info(), so_elem, lo_elem);
406 
407  /*
408  * The new first-order element is ready.
409  * Inserting it into the mesh will replace and delete
410  * the second-order element.
411  */
412  lo_elem->set_id(so_elem->id());
413 #ifdef LIBMESH_ENABLE_UNIQUE_ID
414  lo_elem->set_unique_id() = so_elem->unique_id();
415 #endif
416  lo_elem->processor_id() = so_elem->processor_id();
417  lo_elem->subdomain_id() = so_elem->subdomain_id();
418  this->insert_elem(lo_elem);
419  }
420 
421  const MeshBase::node_iterator nd_end = this->nodes_end();
422  MeshBase::node_iterator nd = this->nodes_begin();
423  while (nd != nd_end)
424  {
425  Node * the_node = *nd;
426  ++nd;
427  if (!node_touched_by_me[the_node->id()])
428  this->delete_node(the_node);
429  }
430 
431  // If crazy people applied boundary info to non-vertices and then
432  // deleted those non-vertices, we should make sure their boundary id
433  // caches are correct.
435 
436  STOP_LOG("all_first_order()", "Mesh");
437 
438  // On hanging nodes that used to also be second order nodes, we
439  // might now have an invalid nodal processor_id()
441 
442  // delete or renumber nodes if desired
443  this->prepare_for_use();
444 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
static UniquePtr< Elem > build(const ElemType type, Elem *p=libmesh_nullptr)
Definition: elem.C:234
static void set_node_processor_ids(MeshBase &mesh)
Definition: partitioner.C:431
virtual dof_id_type max_node_id() const =0
libmesh_assert(j)
virtual node_iterator nodes_begin()=0
virtual element_iterator elements_begin()=0
virtual element_iterator elements_end()=0
virtual void delete_node(Node *n)=0
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:173
virtual Elem * insert_elem(Elem *e)=0
virtual node_iterator nodes_end()=0
void copy_boundary_ids(const BoundaryInfo &old_boundary_info, const Elem *const old_elem, const Elem *const new_elem)
static ElemType first_order_equivalent_type(const ElemType et)
Definition: elem.C:2746
virtual void renumber_nodes_and_elements()=0
const RemoteElem * remote_elem
Definition: remote_elem.C:57
void libMesh::UnstructuredMesh::all_second_order ( const bool  full_ordered = true)
virtualinherited

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 448 of file mesh_modification.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_serial(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::MeshBase::point(), libMesh::MeshBase::prepare_for_use(), 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::subdomain_id(), libMesh::Elem::type(), and libMesh::DofObject::unique_id().

Referenced by libMesh::MeshTools::Generation::build_cube(), and libMesh::MeshTools::Generation::build_sphere().

449 {
450  // This function must be run on all processors at once
451  parallel_object_only();
452 
453  /*
454  * when the mesh is not prepared,
455  * at least renumber the nodes and
456  * elements, so that the node ids
457  * are correct
458  */
459  if (!this->_is_prepared)
461 
462  /*
463  * If the mesh is empty
464  * then we have nothing to do
465  */
466  if (!this->n_elem())
467  return;
468 
469  /*
470  * If the mesh is already second order
471  * then we have nothing to do.
472  * We have to test for this in a round-about way to avoid
473  * a bug on distributed parallel meshes with more processors
474  * than elements.
475  */
476  bool already_second_order = false;
477  if (this->elements_begin() != this->elements_end() &&
478  (*(this->elements_begin()))->default_order() != FIRST)
479  already_second_order = true;
480  this->comm().max(already_second_order);
481  if (already_second_order)
482  return;
483 
484  START_LOG("all_second_order()", "Mesh");
485 
486  /*
487  * this map helps in identifying second order
488  * nodes. Namely, a second-order node:
489  * - edge node
490  * - face node
491  * - bubble node
492  * is uniquely defined through a set of adjacent
493  * vertices. This set of adjacent vertices is
494  * used to identify already added higher-order
495  * nodes. We are safe to use node id's since we
496  * make sure that these are correctly numbered.
497  */
498  std::map<std::vector<dof_id_type>, Node *> adj_vertices_to_so_nodes;
499 
500  /*
501  * for speed-up of the \p add_point() method, we
502  * can reserve memory. Guess the number of additional
503  * nodes for different dimensions
504  */
505  switch (this->mesh_dimension())
506  {
507  case 1:
508  /*
509  * in 1D, there can only be order-increase from Edge2
510  * to Edge3. Something like 1/2 of n_nodes() have
511  * to be added
512  */
513  this->reserve_nodes(static_cast<unsigned int>
514  (1.5*static_cast<double>(this->n_nodes())));
515  break;
516 
517  case 2:
518  /*
519  * in 2D, either refine from Tri3 to Tri6 (double the nodes)
520  * or from Quad4 to Quad8 (again, double) or Quad9 (2.25 that much)
521  */
522  this->reserve_nodes(static_cast<unsigned int>
523  (2*static_cast<double>(this->n_nodes())));
524  break;
525 
526 
527  case 3:
528  /*
529  * in 3D, either refine from Tet4 to Tet10 (factor = 2.5) up to
530  * Hex8 to Hex27 (something > 3). Since in 3D there _are_ already
531  * quite some nodes, and since we do not want to overburden the memory by
532  * a too conservative guess, use the lower bound
533  */
534  this->reserve_nodes(static_cast<unsigned int>
535  (2.5*static_cast<double>(this->n_nodes())));
536  break;
537 
538  default:
539  // Hm?
540  libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
541  }
542 
543 
544 
545  /*
546  * form a vector that will hold the node id's of
547  * the vertices that are adjacent to the son-th
548  * second-order node. Pull this outside of the
549  * loop so that silly compilers don't repeatedly
550  * create and destroy the vector.
551  */
552  std::vector<dof_id_type> adjacent_vertices_ids;
553 
560  element_iterator
561  it = elements_begin(),
562  endit = elements_end();
563 
564  for (; it != endit; ++it)
565  {
566  // the linear-order element
567  Elem * lo_elem = *it;
568 
569  libmesh_assert(lo_elem);
570 
571  // make sure it is linear order
572  if (lo_elem->default_order() != FIRST)
573  libmesh_error_msg("ERROR: This is not a linear element: type=" << lo_elem->type());
574 
575  // this does _not_ work for refined elements
576  libmesh_assert_equal_to (lo_elem->level (), 0);
577 
578  /*
579  * build the second-order equivalent, add to
580  * the new_elements list. Note that this here
581  * is the only point where \p full_ordered
582  * is necessary. The remaining code works well
583  * for either type of second-order equivalent, e.g.
584  * Hex20 or Hex27, as equivalents for Hex8
585  */
586  Elem * so_elem =
588  full_ordered) ).release();
589 
590  libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());
591 
592 
593  /*
594  * By definition the vertices of the linear and
595  * second order element are identically numbered.
596  * transfer these.
597  */
598  for (unsigned int v=0; v < lo_elem->n_vertices(); v++)
599  so_elem->set_node(v) = lo_elem->node_ptr(v);
600 
601  /*
602  * Now handle the additional mid-side nodes. This
603  * is simply handled through a map that remembers
604  * the already-added nodes. This map maps the global
605  * ids of the vertices (that uniquely define this
606  * higher-order node) to the new node.
607  * Notation: son = second-order node
608  */
609  const unsigned int son_begin = so_elem->n_vertices();
610  const unsigned int son_end = so_elem->n_nodes();
611 
612 
613  for (unsigned int son=son_begin; son<son_end; son++)
614  {
615  const unsigned int n_adjacent_vertices =
616  so_elem->n_second_order_adjacent_vertices(son);
617 
618  adjacent_vertices_ids.resize(n_adjacent_vertices);
619 
620  for (unsigned int v=0; v<n_adjacent_vertices; v++)
621  adjacent_vertices_ids[v] =
622  so_elem->node_id( so_elem->second_order_adjacent_vertex(son,v) );
623 
624  /*
625  * \p adjacent_vertices_ids is now in order of the current
626  * side. sort it, so that comparisons with the
627  * \p adjacent_vertices_ids created through other elements'
628  * sides can match
629  */
630  std::sort(adjacent_vertices_ids.begin(),
631  adjacent_vertices_ids.end());
632 
633 
634  // does this set of vertices already has a mid-node added?
635  std::pair<std::map<std::vector<dof_id_type>, Node *>::iterator,
636  std::map<std::vector<dof_id_type>, Node *>::iterator>
637  pos = adj_vertices_to_so_nodes.equal_range (adjacent_vertices_ids);
638 
639  // no, not added yet
640  if (pos.first == pos.second)
641  {
642  /*
643  * for this set of vertices, there is no
644  * second_order node yet. Add it.
645  *
646  * compute the location of the new node as
647  * the average over the adjacent vertices.
648  */
649  Point new_location = this->point(adjacent_vertices_ids[0]);
650  for (unsigned int v=1; v<n_adjacent_vertices; v++)
651  new_location += this->point(adjacent_vertices_ids[v]);
652 
653  new_location /= static_cast<Real>(n_adjacent_vertices);
654 
655  /* Add the new point to the mesh.
656  * If we are on a serialized mesh, then we're doing this
657  * all in sync, and the node processor_id will be
658  * consistent between processors.
659  * If we are on a distributed mesh, we can fix
660  * inconsistent processor ids later, but only if every
661  * processor gives new nodes a *locally* consistent
662  * processor id, so we'll give the new node the
663  * processor id of an adjacent element for now and then
664  * we'll update that later if appropriate.
665  */
666  Node * so_node = this->add_point
667  (new_location, DofObject::invalid_id,
668  lo_elem->processor_id());
669 
670  /*
671  * insert the new node with its defining vertex
672  * set into the map, and relocate pos to this
673  * new entry, so that the so_elem can use
674  * \p pos for inserting the node
675  */
676  adj_vertices_to_so_nodes.insert(pos.first,
677  std::make_pair(adjacent_vertices_ids,
678  so_node));
679 
680  so_elem->set_node(son) = so_node;
681  }
682  // yes, already added.
683  else
684  {
685  Node * so_node = pos.first->second;
686  libmesh_assert(so_node);
687 
688  so_elem->set_node(son) = so_node;
689 
690  // We need to ensure that the processor who should own a
691  // node *knows* they own the node.
692  if (so_node->processor_id() > lo_elem->processor_id())
693  so_node->processor_id() = lo_elem->processor_id();
694  }
695  }
696 
697  /*
698  * find_neighbors relies on remote_elem neighbor links being
699  * properly maintained.
700  */
701  for (unsigned short s=0; s<lo_elem->n_sides(); s++)
702  {
703  if (lo_elem->neighbor_ptr(s) == remote_elem)
704  so_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
705  }
706 
719  (this->get_boundary_info(), lo_elem, so_elem);
720 
721  /*
722  * The new second-order element is ready.
723  * Inserting it into the mesh will replace and delete
724  * the first-order element.
725  */
726  so_elem->set_id(lo_elem->id());
727 #ifdef LIBMESH_ENABLE_UNIQUE_ID
728  so_elem->set_unique_id() = lo_elem->unique_id();
729 #endif
730  so_elem->processor_id() = lo_elem->processor_id();
731  so_elem->subdomain_id() = lo_elem->subdomain_id();
732  this->insert_elem(so_elem);
733  }
734 
735  // we can clear the map
736  adj_vertices_to_so_nodes.clear();
737 
738 
739  STOP_LOG("all_second_order()", "Mesh");
740 
741  // In a DistributedMesh our ghost node processor ids may be bad,
742  // the ids of nodes touching remote elements may be inconsistent,
743  // and unique_ids of newly added non-local nodes remain unset.
744  // make_nodes_parallel_consistent() will fix all this.
745  if (!this->is_serial())
746  MeshCommunication().make_nodes_parallel_consistent (*this);
747 
748  // renumber nodes, elements etc
749  this->prepare_for_use(/*skip_renumber =*/ false);
750 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
virtual void reserve_nodes(const dof_id_type nn)=0
virtual bool is_serial() const
Definition: mesh_base.h:137
virtual const Point & point(const dof_id_type i) const =0
static UniquePtr< Elem > build(const ElemType type, Elem *p=libmesh_nullptr)
Definition: elem.C:234
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)=0
libmesh_assert(j)
virtual element_iterator elements_begin()=0
virtual element_iterator elements_end()=0
static const dof_id_type invalid_id
Definition: dof_object.h:334
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:173
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition: elem.C:2804
virtual Elem * insert_elem(Elem *e)=0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void copy_boundary_ids(const BoundaryInfo &old_boundary_info, const Elem *const old_elem, const Elem *const new_elem)
const Parallel::Communicator & comm() const
unsigned int mesh_dimension() const
Definition: mesh_base.C:147
virtual dof_id_type n_nodes() const =0
virtual dof_id_type n_elem() const =0
virtual void renumber_nodes_and_elements()=0
const RemoteElem * remote_elem
Definition: remote_elem.C:57
void libMesh::DistributedMesh::allgather ( )
virtualinherited

Gathers all elements and nodes of the mesh onto every processor

Reimplemented from libMesh::MeshBase.

Definition at line 1434 of file distributed_mesh.C.

References libMesh::DistributedMesh::_is_serial, libMesh::DistributedMesh::_is_serial_on_proc_0, libMesh::MeshCommunication::allgather(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids(), libMesh::DistributedMesh::max_elem_id(), libMesh::DistributedMesh::max_node_id(), libMesh::DistributedMesh::n_elem(), libMesh::DistributedMesh::n_nodes(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_n_elem(), and libMesh::DistributedMesh::parallel_n_nodes().

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

1435 {
1436  if (_is_serial)
1437  return;
1438  MeshCommunication().allgather(*this);
1439  _is_serial = true;
1440  _is_serial_on_proc_0 = true;
1441 
1442  // Make sure our caches are up to date and our
1443  // DofObjects are well packed
1444 #ifdef DEBUG
1445  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1446  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1447  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1448  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1449  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1450  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1451 
1452  // If we've disabled renumbering we can't be sure we're contiguous
1453  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1454  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1455 
1456  // Make sure our neighbor links are all fine
1458 
1459  // Make sure our ids and flags are consistent
1462 #endif
1463 }
virtual dof_id_type n_elem() const libmesh_override
dof_id_type parallel_max_elem_id() const
void libmesh_assert_valid_parallel_flags() const
dof_id_type parallel_max_node_id() const
virtual dof_id_type n_nodes() const libmesh_override
virtual dof_id_type max_node_id() const libmesh_override
virtual dof_id_type parallel_n_nodes() const libmesh_override
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
Definition: mesh_tools.C:1825
virtual dof_id_type parallel_n_elem() const libmesh_override
virtual dof_id_type max_elem_id() const libmesh_override
uint8_t dof_id_type
Definition: id_types.h:64
virtual void libmesh_assert_valid_parallel_ids() const libmesh_override
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 743 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

bool _allow_remote_element_removal
Definition: mesh_base.h:1370
bool libMesh::MeshBase::allow_remote_element_removal ( ) const
inlineinherited
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.

Definition at line 734 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ErrorVector::plot_error(), libMesh::NameBasedIO::read(), and libMesh::GMVIO::read().

bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1362
bool libMesh::MeshBase::allow_renumbering ( ) const
inlineinherited
virtual element_iterator libMesh::DistributedMesh::ancestor_elements_begin ( )
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_element_iterator libMesh::DistributedMesh::ancestor_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::ancestor_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::ancestor_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::bid_nodes_begin ( boundary_id_type  bndry_id)
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_node_iterator libMesh::DistributedMesh::bid_nodes_begin ( boundary_id_type  bndry_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id)
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::bnd_nodes_begin ( )
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_node_iterator libMesh::DistributedMesh::bnd_nodes_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::bnd_nodes_end ( )
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::bnd_nodes_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

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 609 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_spatial_dimension, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::ParallelObject::comm(), end, libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::node(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), and libMesh::Parallel::Communicator::set_union().

Referenced by libMesh::MeshCommunication::broadcast(), libMesh::MeshBase::get_subdomain_name_map(), and libMesh::MeshBase::prepare_for_use().

610 {
611  // This requires an inspection on every processor
612  parallel_object_only();
613 
614  // Need to clear _elem_dims first in case all elements of a
615  // particular dimension have been deleted.
616  _elem_dims.clear();
617 
618  const_element_iterator el = this->active_elements_begin();
619  const_element_iterator end = this->active_elements_end();
620 
621  for (; el!=end; ++el)
622  _elem_dims.insert((*el)->dim());
623 
624  // Some different dimension elements may only live on other processors
625  this->comm().set_union(_elem_dims);
626 
627  // If the largest element dimension found is larger than the current
628  // _spatial_dimension, increase _spatial_dimension.
629  unsigned int max_dim = this->mesh_dimension();
630  if (max_dim > _spatial_dimension)
631  _spatial_dimension = cast_int<unsigned char>(max_dim);
632 
633  // _spatial_dimension may need to increase from 1->2 or 2->3 if the
634  // mesh is full of 1D elements but they are not x-aligned, or the
635  // mesh is full of 2D elements but they are not in the x-y plane.
636  // If the mesh is x-aligned or x-y planar, we will end up checking
637  // every node's coordinates and not breaking out of the loop
638  // early...
639  if (_spatial_dimension < 3)
640  {
641  const_node_iterator node_it = this->nodes_begin();
642  const_node_iterator node_end = this->nodes_end();
643  for (; node_it != node_end; ++node_it)
644  {
645  Node & node = **node_it;
646 
647 #if LIBMESH_DIM > 1
648  // Note: the exact floating point comparison is intentional,
649  // we don't want to get tripped up by tolerances.
650  if (node(1) != 0.)
651  {
652  _spatial_dimension = 2;
653 #if LIBMESH_DIM == 2
654  // If libmesh is compiled in 2D mode, this is the
655  // largest spatial dimension possible so we can break
656  // out.
657  break;
658 #endif
659  }
660 #endif
661 
662 #if LIBMESH_DIM > 2
663  if (node(2) != 0.)
664  {
665  // Spatial dimension can't get any higher than this, so
666  // we can break out.
667  _spatial_dimension = 3;
668  break;
669  }
670 #endif
671  }
672  }
673 }
IterBase * end
unsigned char _spatial_dimension
Definition: mesh_base.h:1390
virtual node_iterator nodes_begin()=0
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1384
virtual element_iterator active_elements_begin()=0
virtual element_iterator active_elements_end()=0
virtual node_iterator nodes_end()=0
const Parallel::Communicator & comm() const
unsigned int mesh_dimension() const
Definition: mesh_base.C:147
virtual const Node & node(const dof_id_type i) const
Definition: mesh_base.h:436
void set_union(T &data, const unsigned int root_id) const
void libMesh::DistributedMesh::clear ( )
virtualinherited

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 774 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_is_serial, libMesh::DistributedMesh::_is_serial_on_proc_0, libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_max_node_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_next_free_local_elem_id, libMesh::DistributedMesh::_next_free_local_node_id, libMesh::DistributedMesh::_next_free_unpartitioned_elem_id, libMesh::DistributedMesh::_next_free_unpartitioned_node_id, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::clear(), end, libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DistributedMesh::clone(), libMesh::DistributedMesh::DistributedMesh(), and libMesh::BoundaryMesh::~BoundaryMesh().

775 {
776  // Call parent clear function
777  MeshBase::clear();
778 
779 
780  // Clear our elements and nodes
781  {
782  elem_iterator_imp it = _elements.begin();
783  const elem_iterator_imp end = _elements.end();
784 
785  // There is no need to remove the elements from
786  // the BoundaryInfo data structure since we
787  // already cleared it.
788  for (; it != end; ++it)
789  delete *it;
790 
791  _elements.clear();
792  }
793 
794  // clear the nodes data structure
795  {
796  node_iterator_imp it = _nodes.begin();
797  node_iterator_imp end = _nodes.end();
798 
799  // There is no need to remove the nodes from
800  // the BoundaryInfo data structure since we
801  // already cleared it.
802  for (; it != end; ++it)
803  delete *it;
804 
805  _nodes.clear();
806  }
807 
808  // We're no longer distributed if we were before
809  _is_serial = true;
810  _is_serial_on_proc_0 = true;
811 
812  // Correct our caches
813  _n_nodes = 0;
814  _n_elem = 0;
815  _max_node_id = 0;
816  _max_elem_id = 0;
821 }
mapvector< Elem *, dof_id_type > _elements
dof_id_type _next_free_local_node_id
processor_id_type n_processors() const
IterBase * end
mapvector< Node *, dof_id_type >::veclike_iterator node_iterator_imp
mapvector< Node *, dof_id_type > _nodes
virtual void clear()
Definition: mesh_base.C:284
dof_id_type _next_free_unpartitioned_node_id
dof_id_type _next_free_unpartitioned_elem_id
mapvector< Elem *, dof_id_type >::veclike_iterator elem_iterator_imp
dof_id_type _next_free_local_elem_id
processor_id_type processor_id() const
virtual void libMesh::DistributedMesh::clear_extra_ghost_elems ( )
inlinevirtualinherited

Clears extra ghost elements.

Definition at line 218 of file distributed_mesh.h.

References libMesh::DistributedMesh::_extra_ghost_elems.

218 { _extra_ghost_elems.clear(); }
std::set< Elem * > _extra_ghost_elems
virtual UniquePtr<MeshBase> libMesh::DistributedMesh::clone ( ) const
inlinevirtualinherited

Virtual copy-constructor, creates a copy of this mesh

Implements libMesh::MeshBase.

Reimplemented in libMesh::ParallelMesh.

Definition at line 91 of file distributed_mesh.h.

References libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::redistribute(), libMesh::DistributedMesh::update_post_partitioning(), and libMesh::DistributedMesh::~DistributedMesh().

92  { return UniquePtr<MeshBase>(new DistributedMesh(*this)); }
DistributedMesh(const Parallel::Communicator &comm_in, unsigned char dim=1)
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_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::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< 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::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DistributedVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), 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::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::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TopologyMap::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), 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::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::DistributedVector< T >::max(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::DistributedVector< T >::min(), 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(), libMesh::ReplicatedMesh::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::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::DistributedVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

88  { return _communicator; }
const Parallel::Communicator & _communicator
bool libMesh::UnstructuredMesh::contract ( )
virtualinherited

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 800 of file unstructured_mesh.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::MeshBase::clear_point_locator(), libMesh::Elem::contract(), libMesh::MeshBase::delete_elem(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::libmesh_assert(), libmesh_nullptr, libMesh::GhostingFunctor::mesh_reinit(), libMesh::Elem::parent(), libMesh::MeshBase::renumber_nodes_and_elements(), and libMesh::Elem::subactive().

801 {
802  LOG_SCOPE ("contract()", "Mesh");
803 
804  // Flag indicating if this call actually changes the mesh
805  bool mesh_changed = false;
806 
807  element_iterator in = elements_begin();
808  const element_iterator end = elements_end();
809 
810 #ifdef DEBUG
811  for ( ; in != end; ++in)
812  if (*in != libmesh_nullptr)
813  {
814  Elem * el = *in;
815  libmesh_assert(el->active() || el->subactive() || el->ancestor());
816  }
817  in = elements_begin();
818 #endif
819 
820  // Loop over the elements.
821  for ( ; in != end; ++in)
822  if (*in != libmesh_nullptr)
823  {
824  Elem * el = *in;
825 
826  // Delete all the subactive ones
827  if (el->subactive())
828  {
829  // No level-0 element should be subactive.
830  // Note that we CAN'T test elem->level(), as that
831  // touches elem->parent()->dim(), and elem->parent()
832  // might have already been deleted!
833  libmesh_assert(el->parent());
834 
835  // Delete the element
836  // This just sets a pointer to NULL, and doesn't
837  // invalidate any iterators
838  this->delete_elem(el);
839 
840  // the mesh has certainly changed
841  mesh_changed = true;
842  }
843  else
844  {
845  // Compress all the active ones
846  if (el->active())
847  el->contract();
848  else
849  libmesh_assert (el->ancestor());
850  }
851  }
852 
853  // Strip any newly-created NULL voids out of the element array
855 
856  // FIXME: Need to understand why deleting subactive children
857  // invalidates the point locator. For now we will clear it explicitly
858  this->clear_point_locator();
859 
860  // Allow our GhostingFunctor objects to reinit if necessary.
861  std::set<GhostingFunctor *>::iterator gf_it = this->ghosting_functors_begin();
862  const std::set<GhostingFunctor *>::iterator gf_end = this->ghosting_functors_end();
863  for (; gf_it != gf_end; ++gf_it)
864  {
865  GhostingFunctor *gf = *gf_it;
866  libmesh_assert(gf);
867  gf->mesh_reinit();
868  }
869 
870  return mesh_changed;
871 }
const class libmesh_nullptr_t libmesh_nullptr
IterBase * end
libmesh_assert(j)
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
Definition: mesh_base.h:789
virtual element_iterator elements_begin()=0
virtual void delete_elem(Elem *e)=0
virtual element_iterator elements_end()=0
void clear_point_locator()
Definition: mesh_base.C:552
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Definition: mesh_base.h:783
virtual void renumber_nodes_and_elements()=0
void libMesh::UnstructuredMesh::copy_nodes_and_elements ( const UnstructuredMesh other_mesh,
const bool  skip_find_neighbors = false 
)
virtualinherited

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

Definition at line 71 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::Elem::child_ptr(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libmesh_nullptr, libMesh::Elem::n_children(), libMesh::MeshBase::n_elem(), libMesh::Elem::n_neighbors(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_neighbor(), libMesh::DofObject::set_unique_id(), libMesh::MeshBase::skip_partitioning(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), and libMesh::Elem::which_child_am_i().

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

73 {
74  LOG_SCOPE("copy_nodes_and_elements()", "UnstructuredMesh");
75 
76  // We're assuming our subclass data needs no copy
77  libmesh_assert_equal_to (_n_parts, other_mesh._n_parts);
78  libmesh_assert_equal_to (_is_prepared, other_mesh._is_prepared);
79 
80  // We're assuming the other mesh has proper element number ordering,
81  // so that we add parents before their children.
82 #ifdef DEBUG
84 #endif
85 
86  //Copy in Nodes
87  {
88  //Preallocate Memory if necessary
89  this->reserve_nodes(other_mesh.n_nodes());
90 
91  const_node_iterator it = other_mesh.nodes_begin();
92  const_node_iterator end = other_mesh.nodes_end();
93 
94  for (; it != end; ++it)
95  {
96  const Node * oldn = *it;
97 
98  // Add new nodes in old node Point locations
99 #ifdef LIBMESH_ENABLE_UNIQUE_ID
100  Node * newn =
101 #endif
102  this->add_point(*oldn, oldn->id(), oldn->processor_id());
103 
104 #ifdef LIBMESH_ENABLE_UNIQUE_ID
105  newn->set_unique_id() = oldn->unique_id();
106 #endif
107  }
108  }
109 
110  //Copy in Elements
111  {
112  //Preallocate Memory if necessary
113  this->reserve_elem(other_mesh.n_elem());
114 
115  // Declare a map linking old and new elements, needed to copy the neighbor lists
116  typedef LIBMESH_BEST_UNORDERED_MAP<const Elem *, Elem *> map_type;
117  map_type old_elems_to_new_elems;
118 
119  // Loop over the elements
120  MeshBase::const_element_iterator it = other_mesh.elements_begin();
121  const MeshBase::const_element_iterator end = other_mesh.elements_end();
122 
123  for (; it != end; ++it)
124  {
125  //Look at the old element
126  const Elem * old = *it;
127  //Build a new element
128  Elem * newparent = old->parent() ?
129  this->elem_ptr(old->parent()->id()) : libmesh_nullptr;
130  UniquePtr<Elem> ap = Elem::build(old->type(), newparent);
131  Elem * el = ap.release();
132 
133  el->subdomain_id() = old->subdomain_id();
134 
135  for (unsigned int s=0; s != old->n_sides(); ++s)
136  if (old->neighbor_ptr(s) == remote_elem)
137  el->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
138 
139 #ifdef LIBMESH_ENABLE_AMR
140  if (old->has_children())
141  for (unsigned int c=0; c != old->n_children(); ++c)
142  if (old->child_ptr(c) == remote_elem)
143  el->add_child(const_cast<RemoteElem *>(remote_elem), c);
144 
145  //Create the parent's child pointers if necessary
146  if (newparent)
147  {
148  unsigned int oldc = old->parent()->which_child_am_i(old);
149  newparent->add_child(el, oldc);
150  }
151 
152  // Copy the refinement flags
153  el->set_refinement_flag(old->refinement_flag());
154 
155  // Use hack_p_level since we may not have sibling elements
156  // added yet
157  el->hack_p_level(old->p_level());
158 
159  el->set_p_refinement_flag(old->p_refinement_flag());
160 #endif // #ifdef LIBMESH_ENABLE_AMR
161 
162  //Assign all the nodes
163  for (unsigned int i=0;i<el->n_nodes();i++)
164  el->set_node(i) = this->node_ptr(old->node_id(i));
165 
166  // And start it off in the same subdomain
167  el->processor_id() = old->processor_id();
168 
169  // Give it the same element and unique ids
170  el->set_id(old->id());
171 
172 #ifdef LIBMESH_ENABLE_UNIQUE_ID
173  el->set_unique_id() = old->unique_id();
174 #endif
175 
176  //Hold onto it
177  if (!skip_find_neighbors)
178  {
179  this->add_elem(el);
180  }
181  else
182  {
183  Elem * new_el = this->add_elem(el);
184  old_elems_to_new_elems[old] = new_el;
185  }
186 
187  // Add the link between the original element and this copy to the map
188  if (skip_find_neighbors)
189  old_elems_to_new_elems[old] = el;
190  }
191 
192  // Loop (again) over the elements to fill in the neighbors
193  if (skip_find_neighbors)
194  {
195  it = other_mesh.elements_begin();
196  for (; it != end; ++it)
197  {
198  Elem * old_elem = *it;
199  Elem * new_elem = old_elems_to_new_elems[old_elem];
200  for (unsigned int s=0; s != old_elem->n_neighbors(); ++s)
201  {
202  const Elem * old_neighbor = old_elem->neighbor_ptr(s);
203  Elem * new_neighbor = old_elems_to_new_elems[old_neighbor];
204  new_elem->set_neighbor(s, new_neighbor);
205  }
206  }
207  }
208  }
209 
210  //Finally prepare the new Mesh for use. Keep the same numbering and
211  //partitioning for now.
212  this->allow_renumbering(false);
213  this->allow_remote_element_removal(false);
214  this->skip_partitioning(true);
215 
216  this->prepare_for_use(false, skip_find_neighbors);
217 
218  //But in the long term, use the same renumbering and partitioning
219  //policies as our source mesh.
220  this->allow_renumbering(other_mesh.allow_renumbering());
221  this->allow_remote_element_removal(other_mesh.allow_remote_element_removal());
222  this->skip_partitioning(other_mesh.skip_partitioning());
223 }
unique_id_type & set_unique_id()
Definition: dof_object.h:654
virtual void reserve_nodes(const dof_id_type nn)=0
static UniquePtr< Elem > build(const ElemType type, Elem *p=libmesh_nullptr)
Definition: elem.C:234
bool skip_partitioning() const
Definition: mesh_base.h:760
const class libmesh_nullptr_t libmesh_nullptr
virtual const Node * node_ptr(const dof_id_type i) const =0
IterBase * end
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)=0
unsigned int _n_parts
Definition: mesh_base.h:1315
virtual Elem * add_elem(Elem *e)=0
void libmesh_assert_valid_amr_elem_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1182
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:173
bool allow_renumbering() const
Definition: mesh_base.h:735
virtual const Elem * elem_ptr(const dof_id_type i) const =0
bool allow_remote_element_removal() const
Definition: mesh_base.h:744
virtual void reserve_elem(const dof_id_type ne)=0
processor_id_type processor_id() const
Definition: dof_object.h:686
const RemoteElem * remote_elem
Definition: remote_elem.C:57
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 679 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.

681 {
682 
683  // Issue a warning if the number the number of processors
684  // currently available is less that that requested for
685  // partitioning. This is not necessarily an error since
686  // you may run on one processor and still partition the
687  // mesh into several partitions.
688 #ifdef DEBUG
689  if (this->n_processors() < pid)
690  {
691  libMesh::out << "WARNING: You are creating a "
692  << "mesh for a processor id (="
693  << pid
694  << ") greater than "
695  << "the number of processors available for "
696  << "the calculation. (="
697  << this->n_processors()
698  << ")."
699  << std::endl;
700  }
701 #endif
702 
703  // Create iterators to loop over the list of elements
704  // const_active_pid_elem_iterator it(this->elements_begin(), pid);
705  // const const_active_pid_elem_iterator it_end(this->elements_end(), pid);
706 
707  const_element_iterator it = this->active_pid_elements_begin(pid);
708  const const_element_iterator it_end = this->active_pid_elements_end(pid);
709 
710  this->create_submesh (pid_mesh, it, it_end);
711 }
processor_id_type n_processors() const
void create_submesh(UnstructuredMesh &new_mesh, const_element_iterator &it, const const_element_iterator &it_end) const
virtual element_iterator active_pid_elements_begin(processor_id_type proc_id)=0
virtual element_iterator active_pid_elements_end(processor_id_type proc_id)=0
OStreamProxy out(std::cout)
void libMesh::UnstructuredMesh::create_submesh ( UnstructuredMesh new_mesh,
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 719 of file unstructured_mesh.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::MeshBase::node_ptr(), libMesh::Elem::point(), 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(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::DofObject::unique_id().

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

722 {
723  // Just in case the subdomain_mesh already has some information
724  // in it, get rid of it.
725  new_mesh.clear();
726 
727  // If we're not serial, our submesh isn't either.
728  // There are no remote elements to delete on an empty mesh, but
729  // calling the method to do so marks the mesh as parallel.
730  if (!this->is_serial())
731  new_mesh.delete_remote_elements();
732 
733  // Fail if (*this == new_mesh), we cannot create a submesh inside ourself!
734  // This may happen if the user accidentally passes the original mesh into
735  // this function! We will check this by making sure we did not just
736  // clear ourself.
737  libmesh_assert_not_equal_to (this->n_nodes(), 0);
738  libmesh_assert_not_equal_to (this->n_elem(), 0);
739 
740  // Container to catch boundary IDs handed back by BoundaryInfo
741  std::vector<boundary_id_type> bc_ids;
742 
743  for (; it != it_end; ++it)
744  {
745  const Elem * old_elem = *it;
746 
747  // Add an equivalent element type to the new_mesh.
748  // Copy ids for this element.
749  Elem * new_elem = Elem::build(old_elem->type()).release();
750  new_elem->set_id() = old_elem->id();
751 #ifdef LIBMESH_ENABLE_UNIQUE_ID
752  new_elem->set_unique_id() = old_elem->unique_id();
753 #endif
754  new_elem->subdomain_id() = old_elem->subdomain_id();
755  new_elem->processor_id() = old_elem->processor_id();
756 
757  new_mesh.add_elem (new_elem);
758 
759  libmesh_assert(new_elem);
760 
761  // Loop over the nodes on this element.
762  for (unsigned int n=0; n<old_elem->n_nodes(); n++)
763  {
764  const dof_id_type this_node_id = old_elem->node_id(n);
765 
766  // Add this node to the new mesh if it's not there already
767  if (!new_mesh.query_node_ptr(this_node_id))
768  {
769 #ifdef LIBMESH_ENABLE_UNIQUE_ID
770  Node *newn =
771 #endif
772  new_mesh.add_point (old_elem->point(n),
773  this_node_id,
774  old_elem->node_ptr(n)->processor_id());
775 
776 #ifdef LIBMESH_ENABLE_UNIQUE_ID
777  newn->set_unique_id() = old_elem->node_ptr(n)->unique_id();
778 #endif
779  }
780 
781  // Define this element's connectivity on the new mesh
782  new_elem->set_node(n) = new_mesh.node_ptr(this_node_id);
783  }
784 
785  // Maybe add boundary conditions for this element
786  for (unsigned short s=0; s<old_elem->n_sides(); s++)
787  {
788  this->get_boundary_info().boundary_ids(old_elem, s, bc_ids);
789  new_mesh.get_boundary_info().add_side (new_elem, s, bc_ids);
790  }
791  } // end loop over elements
792 
793  // Prepare the new_mesh for use
794  new_mesh.prepare_for_use(/*skip_renumber =*/false);
795 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
virtual bool is_serial() const
Definition: mesh_base.h:137
static UniquePtr< Elem > build(const ElemType type, Elem *p=libmesh_nullptr)
Definition: elem.C:234
libmesh_assert(j)
std::vector< boundary_id_type > boundary_ids(const Node *node) const
virtual dof_id_type n_nodes() const =0
virtual dof_id_type n_elem() const =0
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::DistributedMesh::delete_elem ( Elem e)
virtualinherited

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 539 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_n_elem, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::BoundaryInfo::remove().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::insert_elem(), and libMesh::DistributedMesh::reserve_elem().

540 {
541  libmesh_assert (e);
542 
543  // Try to make the cached elem data more accurate
544  processor_id_type elem_procid = e->processor_id();
545  if (elem_procid == this->processor_id() ||
546  elem_procid == DofObject::invalid_processor_id)
547  _n_elem--;
548 
549  // Delete the element from the BoundaryInfo object
550  this->get_boundary_info().remove(e);
551 
552  // But not yet from the container; we might invalidate
553  // an iterator that way!
554 
555  //_elements.erase(e->id());
556 
557  // Instead, we set it to NULL for now
558 
559  _elements[e->id()] = libmesh_nullptr;
560 
561  // delete the element
562  delete e;
563 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
mapvector< Elem *, dof_id_type > _elements
void remove(const Node *node)
uint8_t processor_id_type
Definition: id_types.h:99
const class libmesh_nullptr_t libmesh_nullptr
libmesh_assert(j)
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
processor_id_type processor_id() const
void libMesh::DistributedMesh::delete_node ( Node n)
virtualinherited

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 710 of file distributed_mesh.C.

References libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::BoundaryInfo::remove().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::DistributedMesh::reserve_elem().

711 {
712  libmesh_assert(n);
713  libmesh_assert(_nodes[n->id()]);
714 
715  // Try to make the cached elem data more accurate
716  processor_id_type node_procid = n->processor_id();
717  if (node_procid == this->processor_id() ||
718  node_procid == DofObject::invalid_processor_id)
719  _n_nodes--;
720 
721  // Delete the node from the BoundaryInfo object
722  this->get_boundary_info().remove(n);
723 
724  // But not yet from the container; we might invalidate
725  // an iterator that way!
726 
727  //_nodes.erase(n->id());
728 
729  // Instead, we set it to NULL for now
730 
731  _nodes[n->id()] = libmesh_nullptr;
732 
733  // delete the node
734  delete n;
735 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
void remove(const Node *node)
uint8_t processor_id_type
Definition: id_types.h:99
const class libmesh_nullptr_t libmesh_nullptr
libmesh_assert(j)
mapvector< Node *, dof_id_type > _nodes
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
processor_id_type processor_id() const
void libMesh::DistributedMesh::delete_remote_elements ( )
virtualinherited

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 from libMesh::MeshBase.

Definition at line 1354 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_extra_ghost_elems, libMesh::DistributedMesh::_is_serial, libMesh::DistributedMesh::_is_serial_on_proc_0, libMesh::DistributedMesh::_nodes, libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::DistributedMesh::max_elem_id(), libMesh::DistributedMesh::max_node_id(), libMesh::DistributedMesh::n_elem(), libMesh::DistributedMesh::n_nodes(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), and libMesh::DistributedMesh::update_parallel_id_counts().

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

1355 {
1356 #ifdef DEBUG
1357  // Make sure our neighbor links are all fine
1359 
1360  // And our child/parent links, and our flags
1362 
1363  // Make sure our ids and flags are consistent
1366 
1367  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1368  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1369  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1370  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1371  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1372  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1373 #endif
1374 
1375  _is_serial = false;
1376  _is_serial_on_proc_0 = false;
1377 
1378  MeshCommunication().delete_remote_elements(*this, _extra_ghost_elems);
1379 
1380  libmesh_assert_equal_to (this->max_elem_id(), this->parallel_max_elem_id());
1381 
1382  // Now make sure the containers actually shrink - strip
1383  // any newly-created NULL voids out of the element array
1384  mapvector<Elem *,dof_id_type>::veclike_iterator e_it = _elements.begin();
1385  const mapvector<Elem *,dof_id_type>::veclike_iterator e_end = _elements.end();
1386  for (; e_it != e_end;)
1387  if (!*e_it)
1388  _elements.erase(e_it++);
1389  else
1390  ++e_it;
1391 
1392  mapvector<Node *,dof_id_type>::veclike_iterator n_it = _nodes.begin();
1393  const mapvector<Node *,dof_id_type>::veclike_iterator n_end = _nodes.end();
1394  for (; n_it != n_end;)
1395  if (!*n_it)
1396  _nodes.erase(n_it++);
1397  else
1398  ++n_it;
1399 
1400  // We may have deleted no-longer-connected nodes or coarsened-away
1401  // elements; let's update our caches.
1402  this->update_parallel_id_counts();
1403 
1404 #ifdef DEBUG
1405  // We might not have well-packed objects if the user didn't allow us
1406  // to renumber
1407  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1408  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1409 
1410  // Make sure our neighbor links are all fine
1412 
1413  // And our child/parent links, and our flags
1415 
1416  // Make sure our ids and flags are consistent
1419 #endif
1420 }
mapvector< Elem *, dof_id_type > _elements
virtual dof_id_type n_elem() const libmesh_override
void libmesh_assert_valid_refinement_tree(const MeshBase &mesh)
Definition: mesh_tools.C:1783
dof_id_type parallel_max_elem_id() const
void libmesh_assert_valid_parallel_flags() const
virtual void update_parallel_id_counts() libmesh_override
dof_id_type parallel_max_node_id() const
mapvector< Node *, dof_id_type > _nodes
std::set< Elem * > _extra_ghost_elems
virtual dof_id_type n_nodes() const libmesh_override
virtual dof_id_type max_node_id() const libmesh_override
virtual dof_id_type parallel_n_nodes() const libmesh_override
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
Definition: mesh_tools.C:1825
virtual dof_id_type parallel_n_elem() const libmesh_override
virtual dof_id_type max_elem_id() const libmesh_override
uint8_t dof_id_type
Definition: id_types.h:64
virtual void libmesh_assert_valid_parallel_ids() const libmesh_override
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 675 of file mesh_base.C.

References libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::Elem::dim(), libMesh::MeshBase::elem(), libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), libMesh::MeshBase::elements_begin(), end, libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::MeshBase::max_elem_id(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), and libMesh::Elem::set_interior_parent().

Referenced by libMesh::MeshBase::get_subdomain_name_map(), and libMesh::MeshBase::prepare_for_use().

676 {
677  // This requires an inspection on every processor
678  parallel_object_only();
679 
680  // Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
681  if (this->elem_dimensions().size() == 1)
682  return;
683 
684  //This map will be used to set interior parents
685  LIBMESH_BEST_UNORDERED_MAP<dof_id_type, std::vector<dof_id_type> > node_to_elem;
686 
687  const_element_iterator el = this->active_elements_begin();
688  const_element_iterator end = this->active_elements_end();
689 
690  for (; el!=end; ++el)
691  {
692  const Elem * elem = *el;
693 
694  // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
695  for (unsigned int n=0; n<elem->n_vertices(); n++)
696  {
697  libmesh_assert_less (elem->id(), this->max_elem_id());
698 
699  node_to_elem[elem->node_id(n)].push_back(elem->id());
700  }
701  }
702 
703  // Automatically set interior parents
704  el = this->elements_begin();
705  for (; el!=end; ++el)
706  {
707  Elem * element = *el;
708 
709  // Ignore an 3D element or an element that already has an interior parent
710  if (element->dim()>=LIBMESH_DIM || element->interior_parent())
711  continue;
712 
713  // Start by generating a SET of elements that are dim+1 to the current
714  // element at each vertex of the current element, thus ignoring interior nodes.
715  // If one of the SET of elements is empty, then we will not have an interior parent
716  // since an interior parent must be connected to all vertices of the current element
717  std::vector< std::set<dof_id_type> > neighbors( element->n_vertices() );
718 
719  bool found_interior_parents = false;
720 
721  for (dof_id_type n=0; n < element->n_vertices(); n++)
722  {
723  std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
724  for (std::vector<dof_id_type>::iterator e_it = element_ids.begin();
725  e_it != element_ids.end(); e_it++)
726  {
727  dof_id_type eid = *e_it;
728  if (this->elem_ref(eid).dim() == element->dim()+1)
729  neighbors[n].insert(eid);
730  }
731  if (neighbors[n].size()>0)
732  {
733  found_interior_parents = true;
734  }
735  else
736  {
737  // We have found an empty set, no reason to continue
738  // Ensure we set this flag to false before the break since it could have
739  // been set to true for previous vertex
740  found_interior_parents = false;
741  break;
742  }
743  }
744 
745  // If we have successfully generated a set of elements for each vertex, we will compare
746  // the set for vertex 0 will the sets for the vertices until we find a id that exists in
747  // all sets. If found, this is our an interior parent id. The interior parent id found
748  // will be the lowest element id if there is potential for multiple interior parents.
749  if (found_interior_parents)
750  {
751  std::set<dof_id_type> & neighbors_0 = neighbors[0];
752  for (std::set<dof_id_type>::iterator e_it = neighbors_0.begin();
753  e_it != neighbors_0.end(); e_it++)
754  {
755  found_interior_parents=false;
756  dof_id_type interior_parent_id = *e_it;
757  for (dof_id_type n=1; n < element->n_vertices(); n++)
758  {
759  if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
760  {
761  found_interior_parents=true;
762  }
763  else
764  {
765  found_interior_parents=false;
766  break;
767  }
768  }
769  if (found_interior_parents)
770  {
771  element->set_interior_parent(this->elem_ptr(interior_parent_id));
772  break;
773  }
774  }
775  }
776  }
777 }
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:515
IterBase * end
virtual element_iterator elements_begin()=0
virtual dof_id_type max_elem_id() const =0
const std::set< unsigned char > & elem_dimensions() const
Definition: mesh_base.h:203
virtual element_iterator active_elements_begin()=0
virtual element_iterator active_elements_end()=0
virtual const Elem & elem_ref(const dof_id_type i) const
Definition: mesh_base.h:483
virtual unsigned int dim() const =0
virtual const Elem * elem_ptr(const dof_id_type i) const =0
uint8_t dof_id_type
Definition: id_types.h:64
virtual const Elem* libMesh::MeshBase::elem ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A pointer to the $ i^{th} $ 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 515 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

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

516  {
517  libmesh_deprecated();
518  return this->elem_ptr(i);
519  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual Elem* libMesh::MeshBase::elem ( const dof_id_type  i)
inlinevirtualinherited
Returns
A writable pointer to the $ i^{th} $ 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 528 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr(), and libMesh::MeshBase::query_elem_ptr().

529  {
530  libmesh_deprecated();
531  return this->elem_ptr(i);
532  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0
const std::set<unsigned char>& libMesh::MeshBase::elem_dimensions ( ) const
inlineinherited
const Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i) const
virtualinherited
Returns
A pointer to the $ i^{th} $ element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 355 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, and libMesh::libmesh_assert().

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

356 {
358  libmesh_assert_equal_to (_elements[i]->id(), i);
359 
360  return _elements[i];
361 }
mapvector< Elem *, dof_id_type > _elements
libmesh_assert(j)
Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i)
virtualinherited
Returns
A writable pointer to the $ i^{th} $ element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 366 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, and libMesh::libmesh_assert().

367 {
369  libmesh_assert_equal_to (_elements[i]->id(), i);
370 
371  return _elements[i];
372 }
mapvector< Elem *, dof_id_type > _elements
libmesh_assert(j)
virtual Elem& libMesh::MeshBase::elem_ref ( const dof_id_type  i)
inlinevirtualinherited
Returns
A writable reference to the $ i^{th} $ element, which should be present in this processor's subset of the mesh data structure.

Definition at line 492 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

492  {
493  return *this->elem_ptr(i);
494  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual element_iterator libMesh::DistributedMesh::elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual const_element_iterator libMesh::DistributedMesh::elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

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

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.

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

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

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::evaluable_elements_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::evaluable_elements_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
virtualinherited

Implements libMesh::MeshBase.

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

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.

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

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

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::evaluable_nodes_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::evaluable_nodes_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::facelocal_elements_begin ( )
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_element_iterator libMesh::DistributedMesh::facelocal_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::facelocal_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::facelocal_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

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

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 NULL 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 238 of file unstructured_mesh.C.

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::centroid(), libMesh::Elem::child_ptr(), libMesh::Elem::dim(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, 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::key(), libMesh::Elem::level(), libMesh::MeshBase::level_elements_begin(), libMesh::MeshBase::level_elements_end(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libmesh_nullptr, libMesh::Elem::n_children(), libMesh::MeshTools::n_levels(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Elem::point(), 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(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), and libMesh::DistributedMesh::redistribute().

240 {
241  // We might actually want to run this on an empty mesh
242  // (e.g. the boundary mesh for a nonexistent bcid!)
243  // libmesh_assert_not_equal_to (this->n_nodes(), 0);
244  // libmesh_assert_not_equal_to (this->n_elem(), 0);
245 
246  // This function must be run on all processors at once
247  parallel_object_only();
248 
249  LOG_SCOPE("find_neighbors()", "Mesh");
250 
251  const element_iterator el_end = this->elements_end();
252 
253  //TODO:[BSK] This should be removed later?!
254  if (reset_current_list)
255  for (element_iterator el = this->elements_begin(); el != el_end; ++el)
256  {
257  Elem * e = *el;
258  for (unsigned int s=0; s<e->n_neighbors(); s++)
259  if (e->neighbor_ptr(s) != remote_elem ||
260  reset_remote_elements)
261  e->set_neighbor(s, libmesh_nullptr);
262  }
263 
264  // Find neighboring elements by first finding elements
265  // with identical side keys and then check to see if they
266  // are neighbors
267  {
268  // data structures -- Use the hash_multimap if available
269  typedef unsigned int key_type;
270  typedef std::pair<Elem *, unsigned char> val_type;
271  typedef std::pair<key_type, val_type> key_val_pair;
272 
273  typedef LIBMESH_BEST_UNORDERED_MULTIMAP<key_type, val_type> map_type;
274 
275  // A map from side keys to corresponding elements & side numbers
276  map_type side_to_elem_map;
277 
278 
279 
280  for (element_iterator el = this->elements_begin(); el != el_end; ++el)
281  {
282  Elem * element = *el;
283 
284  for (unsigned char ms=0; ms<element->n_neighbors(); ms++)
285  {
286  next_side:
287  // If we haven't yet found a neighbor on this side, try.
288  // Even if we think our neighbor is remote, that
289  // information may be out of date.
290  if (element->neighbor_ptr(ms) == libmesh_nullptr ||
291  element->neighbor_ptr(ms) == remote_elem)
292  {
293  // Get the key for the side of this element
294  const unsigned int key = element->key(ms);
295 
296  // Look for elements that have an identical side key
297  std::pair <map_type::iterator, map_type::iterator>
298  bounds = side_to_elem_map.equal_range(key);
299 
300  // May be multiple keys, check all the possible
301  // elements which _might_ be neighbors.
302  if (bounds.first != bounds.second)
303  {
304  // Get the side for this element
305  const UniquePtr<Elem> my_side(element->side_ptr(ms));
306 
307  // Look at all the entries with an equivalent key
308  while (bounds.first != bounds.second)
309  {
310  // Get the potential element
311  Elem * neighbor = bounds.first->second.first;
312 
313  // Get the side for the neighboring element
314  const unsigned int ns = bounds.first->second.second;
315  const UniquePtr<Elem> their_side(neighbor->side_ptr(ns));
316  //libmesh_assert(my_side.get());
317  //libmesh_assert(their_side.get());
318 
319  // If found a match with my side
320  //
321  // We need special tests here for 1D:
322  // since parents and children have an equal
323  // side (i.e. a node), we need to check
324  // ns != ms, and we also check level() to
325  // avoid setting our neighbor pointer to
326  // any of our neighbor's descendants
327  if ((*my_side == *their_side) &&
328  (element->level() == neighbor->level()) &&
329  ((element->dim() != 1) || (ns != ms)))
330  {
331  // So share a side. Is this a mixed pair
332  // of subactive and active/ancestor
333  // elements?
334  // If not, then we're neighbors.
335  // If so, then the subactive's neighbor is
336 
337  if (element->subactive() ==
338  neighbor->subactive())
339  {
340  // an element is only subactive if it has
341  // been coarsened but not deleted
342  element->set_neighbor (ms,neighbor);
343  neighbor->set_neighbor(ns,element);
344  }
345  else if (element->subactive())
346  {
347  element->set_neighbor(ms,neighbor);
348  }
349  else if (neighbor->subactive())
350  {
351  neighbor->set_neighbor(ns,element);
352  }
353  side_to_elem_map.erase (bounds.first);
354 
355  // get out of this nested crap
356  goto next_side;
357  }
358 
359  ++bounds.first;
360  }
361  }
362 
363  // didn't find a match...
364  // Build the map entry for this element
365  key_val_pair kvp;
366 
367  kvp.first = key;
368  kvp.second.first = element;
369  kvp.second.second = ms;
370 
371  // use the lower bound as a hint for
372  // where to put it.
373 #if defined(LIBMESH_HAVE_UNORDERED_MAP) || defined(LIBMESH_HAVE_TR1_UNORDERED_MAP) || defined(LIBMESH_HAVE_HASH_MAP) || defined(LIBMESH_HAVE_EXT_HASH_MAP)
374  side_to_elem_map.insert (kvp);
375 #else
376  side_to_elem_map.insert (bounds.first,kvp);
377 #endif
378  }
379  }
380  }
381  }
382 
383 #ifdef LIBMESH_ENABLE_AMR
384 
412  const unsigned int n_levels = MeshTools::n_levels(*this);
413  for (unsigned int level = 1; level < n_levels; ++level)
414  {
415  element_iterator end = this->level_elements_end(level);
416  for (element_iterator el = this->level_elements_begin(level);
417  el != end; ++el)
418  {
419  Elem * current_elem = *el;
420  libmesh_assert(current_elem);
421  Elem * parent = current_elem->parent();
422  libmesh_assert(parent);
423  const unsigned int my_child_num = parent->which_child_am_i(current_elem);
424 
425  for (unsigned int s=0; s < current_elem->n_neighbors(); s++)
426  {
427  if (current_elem->neighbor_ptr(s) == libmesh_nullptr ||
428  (current_elem->neighbor_ptr(s) == remote_elem &&
429  parent->is_child_on_side(my_child_num, s)))
430  {
431  Elem * neigh = parent->neighbor_ptr(s);
432 
433  // If neigh was refined and had non-subactive children
434  // made remote earlier, then our current elem should
435  // actually have one of those remote children as a
436  // neighbor
437  if (neigh &&
438  (neigh->ancestor() ||
439  // If neigh has subactive children which should have
440  // matched as neighbors of the current element but
441  // did not, then those likewise must be remote
442  // children.
443  (current_elem->subactive() && neigh->has_children() &&
444  (neigh->level()+1) == current_elem->level())))
445  {
446 #ifdef DEBUG
447  // Let's make sure that "had children made remote"
448  // situation is actually the case
449  libmesh_assert(neigh->has_children());
450  bool neigh_has_remote_children = false;
451  for (unsigned int c = 0; c != neigh->n_children(); ++c)
452  {
453  if (neigh->child_ptr(c) == remote_elem)
454  neigh_has_remote_children = true;
455  }
456  libmesh_assert(neigh_has_remote_children);
457 
458  // And let's double-check that we don't have
459  // a remote_elem neighboring an active local element
460  if (current_elem->active())
461  libmesh_assert_not_equal_to (current_elem->processor_id(),
462  this->processor_id());
463 #endif // DEBUG
464  neigh = const_cast<RemoteElem *>(remote_elem);
465  }
466  // If neigh and current_elem are more than one level
467  // apart, figuring out whether we have a remote
468  // neighbor here becomes much harder.
469  else if (neigh && (current_elem->subactive() &&
470  neigh->has_children()))
471  {
472  // Find the deepest descendant of neigh which
473  // we could consider for a neighbor. If we run
474  // out of neigh children, then that's our
475  // neighbor. If we find a potential neighbor
476  // with remote_children and we don't find any
477  // potential neighbors among its non-remote
478  // children, then our neighbor must be remote.
479  while (neigh != remote_elem &&
480  neigh->has_children())
481  {
482  bool found_neigh = false;
483  for (unsigned int c = 0;
484  !found_neigh &&
485  c != neigh->n_children(); ++c)
486  {
487  Elem * child = neigh->child_ptr(c);
488  if (child == remote_elem)
489  continue;
490  unsigned int n_neigh = child->n_neighbors();
491  for (unsigned int n=0; n != n_neigh; ++n)
492  {
493  Elem * ncn = child->neighbor(n);
494  if (ncn != remote_elem &&
495  ncn->is_ancestor_of(current_elem))
496  {
497  neigh = ncn;
498  found_neigh = true;
499  break;
500  }
501  }
502  }
503  if (!found_neigh)
504  neigh = const_cast<RemoteElem *>(remote_elem);
505  }
506  }
507  current_elem->set_neighbor(s, neigh);
508 #ifdef DEBUG
509  if (neigh != libmesh_nullptr && neigh != remote_elem)
510  // We ignore subactive elements here because
511  // we don't care about neighbors of subactive element.
512  if ((!neigh->active()) && (!current_elem->subactive()))
513  {
514  libMesh::err << "On processor " << this->processor_id()
515  << std::endl;
516  libMesh::err << "Bad element ID = " << current_elem->id()
517  << ", Side " << s << ", Bad neighbor ID = " << neigh->id() << std::endl;
518  libMesh::err << "Bad element proc_ID = " << current_elem->processor_id()
519  << ", Bad neighbor proc_ID = " << neigh->processor_id() << std::endl;
520  libMesh::err << "Bad element size = " << current_elem->hmin()
521  << ", Bad neighbor size = " << neigh->hmin() << std::endl;
522  libMesh::err << "Bad element center = " << current_elem->centroid()
523  << ", Bad neighbor center = " << neigh->centroid() << std::endl;
524  libMesh::err << "ERROR: "
525  << (current_elem->active()?"Active":"Ancestor")
526  << " Element at level "
527  << current_elem->level() << std::endl;
528  libMesh::err << "with "
529  << (parent->active()?"active":
530  (parent->subactive()?"subactive":"ancestor"))
531  << " parent share "
532  << (neigh->subactive()?"subactive":"ancestor")
533  << " neighbor at level " << neigh->level()
534  << std::endl;
535  NameBasedIO(*this).write ("bad_mesh.gmv");
536  libmesh_error_msg("Problematic mesh written to bad_mesh.gmv.");
537  }
538 #endif // DEBUG
539  }
540  }
541 
542  // We can skip to the next element if we're full-dimension
543  // and therefore don't have any interior parents
544  if (current_elem->dim() >= LIBMESH_DIM)
545  continue;
546 
547  // We have no interior parents unless we can find one later
548  current_elem->set_interior_parent(libmesh_nullptr);
549 
550  Elem * pip = parent->interior_parent();
551 
552  if (!pip)
553  continue;
554 
555  // If there's no interior_parent children, whether due to a
556  // remote element or a non-conformity, then there's no
557  // children to search.
558  if (pip == remote_elem || pip->active())
559  {
560  current_elem->set_interior_parent(pip);
561  continue;
562  }
563 
564  // For node comparisons we'll need a sensible tolerance
565  Real node_tolerance = current_elem->hmin() * TOLERANCE;
566 
567  // Otherwise our interior_parent should be a child of our
568  // parent's interior_parent.
569  for (unsigned int c=0; c != pip->n_children(); ++c)
570  {
571  Elem * child = pip->child_ptr(c);
572 
573  // If we have a remote_elem, that might be our
574  // interior_parent. We'll set it provisionally now and
575  // keep trying to find something better.
576  if (child == remote_elem)
577  {
578  current_elem->set_interior_parent
579  (const_cast<RemoteElem *>(remote_elem));
580  continue;
581  }
582 
583  bool child_contains_our_nodes = true;
584  for (unsigned int n=0; n != current_elem->n_nodes();
585  ++n)
586  {
587  bool child_contains_this_node = false;
588  for (unsigned int cn=0; cn != child->n_nodes();
589  ++cn)
590  if (child->point(cn).absolute_fuzzy_equals
591  (current_elem->point(n), node_tolerance))
592  {
593  child_contains_this_node = true;
594  break;
595  }
596  if (!child_contains_this_node)
597  {
598  child_contains_our_nodes = false;
599  break;
600  }
601  }
602  if (child_contains_our_nodes)
603  {
604  current_elem->set_interior_parent(child);
605  break;
606  }
607  }
608 
609  // We should have found *some* interior_parent at this
610  // point, whether semilocal or remote.
611  libmesh_assert(current_elem->interior_parent());
612  }
613  }
614 
615 #endif // AMR
616 
617 
618 #ifdef DEBUG
620  !reset_remote_elements);
622 #endif
623 }
bool has_children() const
Definition: elem.h:2097
void libmesh_assert_valid_amr_interior_parents(const MeshBase &mesh)
Definition: mesh_tools.C:1206
bool active() const
Definition: elem.h:2059
virtual element_iterator level_elements_begin(unsigned int level)=0
const class libmesh_nullptr_t libmesh_nullptr
static const Real TOLERANCE
IterBase * end
libmesh_assert(j)
virtual element_iterator elements_begin()=0
virtual element_iterator level_elements_end(unsigned int level)=0
virtual bool is_child_on_side(const unsigned int, const unsigned int) const libmesh_override
Definition: remote_elem.h:140
bool is_ancestor_of(const Elem *descendant) const
Definition: elem.h:2127
virtual element_iterator elements_end()=0
unsigned int n_levels(const MeshBase &mesh)
Definition: mesh_tools.C:621
OStreamProxy err(std::cerr)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
Definition: mesh_tools.C:1825
processor_id_type processor_id() const
const RemoteElem * remote_elem
Definition: remote_elem.C:57
void libMesh::DistributedMesh::fix_broken_node_and_element_numbering ( )
virtualinherited

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 1301 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_nodes, libMesh::mapvector< Val, index_t >::begin(), libMesh::mapvector< Val, index_t >::end(), end, and libmesh_nullptr.

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

1302 {
1303  // We need access to iterators for the underlying containers,
1304  // not the mapvector<> reimplementations.
1307 
1308  // Nodes first
1309  {
1310  mapvector<Node *,dof_id_type>::maptype::iterator
1311  it = nodes.begin(),
1312  end = nodes.end();
1313 
1314  for (; it != end; ++it)
1315  if (it->second != libmesh_nullptr)
1316  it->second->set_id() = it->first;
1317  }
1318 
1319  // Elements next
1320  {
1321  mapvector<Elem *,dof_id_type>::maptype::iterator
1322  it = elems.begin(),
1323  end = elems.end();
1324 
1325  for (; it != end; ++it)
1326  if (it->second != libmesh_nullptr)
1327  it->second->set_id() = it->first;
1328  }
1329 }
std::map< index_t, Val > maptype
Definition: mapvector.h:42
mapvector< Elem *, dof_id_type > _elements
const class libmesh_nullptr_t libmesh_nullptr
IterBase * end
mapvector< Node *, dof_id_type > _nodes
virtual element_iterator libMesh::DistributedMesh::flagged_elements_begin ( unsigned char  rflag)
virtualinherited

Iterate over all elements with a specified refinement flag.

Implements libMesh::MeshBase.

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

virtual const_element_iterator libMesh::DistributedMesh::flagged_elements_begin ( unsigned char  rflag) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::flagged_elements_end ( unsigned char  rflag)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::flagged_elements_end ( unsigned char  rflag) const
virtualinherited

Implements libMesh::MeshBase.

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

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

Implements libMesh::MeshBase.

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

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

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::flagged_pid_elements_end ( unsigned char  rflag,
processor_id_type  pid 
)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::flagged_pid_elements_end ( unsigned char  rflag,
processor_id_type  pid 
) const
virtualinherited

Implements libMesh::MeshBase.

void libMesh::DistributedMesh::gather_to_zero ( )
virtualinherited

Gathers all elements and nodes of the mesh onto processor zero

Reimplemented from libMesh::MeshBase.

Definition at line 1465 of file distributed_mesh.C.

References libMesh::DistributedMesh::_is_serial_on_proc_0, and libMesh::MeshCommunication::gather().

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

1466 {
1468  return;
1469 
1470  _is_serial_on_proc_0 = true;
1471  MeshCommunication().gather(0, *this);
1472 }
const BoundaryInfo& libMesh::MeshBase::get_boundary_info ( ) const
inlineinherited

The information about boundary ids on the mesh

Definition at line 114 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::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshBase::clear(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::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::BoundaryProjectSolution::operator()(), libMesh::Parallel::Packing< const Node * >::pack(), libMesh::Parallel::Packing< const Elem * >::pack(), libMesh::Parallel::Packing< const Node * >::packable_size(), libMesh::Parallel::Packing< const Elem * >::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::CheckpointIO::read_nodesets(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), libMesh::Elem::topological_neighbor(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

114 { return *boundary_info; }
UniquePtr< BoundaryInfo > boundary_info
Definition: mesh_base.h:1294
BoundaryInfo& libMesh::MeshBase::get_boundary_info ( )
inlineinherited

Writable information about boundary ids on the mesh

Definition at line 119 of file mesh_base.h.

References libMesh::MeshBase::boundary_info, and libMesh::MeshBase::clear().

119 { return *boundary_info; }
UniquePtr< BoundaryInfo > boundary_info
Definition: mesh_base.h:1294
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 566 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

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

567 {
569 }
bool _count_lower_dim_elems_in_point_locator
Definition: mesh_base.h:1335
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 593 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name, and libMesh::Elem::invalid_subdomain_id.

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

594 {
595  // Linear search over the map values.
596  std::map<subdomain_id_type, std::string>::const_iterator
597  iter = _block_id_to_name.begin(),
598  end_iter = _block_id_to_name.end();
599 
600  for ( ; iter != end_iter; ++iter)
601  if (iter->second == name)
602  return iter->first;
603 
604  // If we made it here without returning, we don't have a subdomain
605  // with the requested name, so return Elem::invalid_subdomain_id.
607 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
static const subdomain_id_type invalid_subdomain_id
Definition: elem.h:213
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1377
std::string libMesh::MeshBase::get_info ( ) const
inherited
Returns
A string containing relevant information about the mesh.

Definition at line 413 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::n_partitions(), and libMesh::MeshBase::print_info().

414 {
415  std::ostringstream oss;
416 
417  oss << " Mesh Information:" << '\n';
418 
419  if (!_elem_dims.empty())
420  {
421  oss << " elem_dimensions()={";
422  std::copy(_elem_dims.begin(),
423  --_elem_dims.end(), // --end() is valid if the set is non-empty
424  std::ostream_iterator<unsigned int>(oss, ", "));
425  oss << cast_int<unsigned int>(*_elem_dims.rbegin());
426  oss << "}\n";
427  }
428 
429  oss << " spatial_dimension()=" << this->spatial_dimension() << '\n'
430  << " n_nodes()=" << this->n_nodes() << '\n'
431  << " n_local_nodes()=" << this->n_local_nodes() << '\n'
432  << " n_elem()=" << this->n_elem() << '\n'
433  << " n_local_elem()=" << this->n_local_elem() << '\n'
434 #ifdef LIBMESH_ENABLE_AMR
435  << " n_active_elem()=" << this->n_active_elem() << '\n'
436 #endif
437  << " n_subdomains()=" << static_cast<std::size_t>(this->n_subdomains()) << '\n'
438  << " n_partitions()=" << static_cast<std::size_t>(this->n_partitions()) << '\n'
439  << " n_processors()=" << static_cast<std::size_t>(this->n_processors()) << '\n'
440  << " n_threads()=" << static_cast<std::size_t>(libMesh::n_threads()) << '\n'
441  << " processor_id()=" << static_cast<std::size_t>(this->processor_id()) << '\n';
442 
443  return oss.str();
444 }
virtual dof_id_type n_active_elem() const =0
unsigned int n_threads()
Definition: libmesh_base.h:125
dof_id_type n_local_nodes() const
Definition: mesh_base.h:269
unsigned int n_partitions() const
Definition: mesh_base.h:818
processor_id_type n_processors() const
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1384
unsigned int spatial_dimension() const
Definition: mesh_base.C:156
dof_id_type n_local_elem() const
Definition: mesh_base.h:369
subdomain_id_type n_subdomains() const
Definition: mesh_base.C:333
virtual dof_id_type n_nodes() const =0
virtual dof_id_type n_elem() const =0
processor_id_type processor_id() const
const std::map<subdomain_id_type, std::string>& libMesh::MeshBase::get_subdomain_name_map ( ) const
inlineinherited
virtual element_iterator libMesh::DistributedMesh::ghost_elements_begin ( )
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_element_iterator libMesh::DistributedMesh::ghost_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::ghost_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::ghost_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_begin ( ) const
inlineinherited
Elem * libMesh::DistributedMesh::insert_elem ( Elem e)
virtualinherited

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 505 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_n_elem, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::DistributedMesh::delete_elem(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_unique_id(), and libMesh::DofObject::valid_unique_id().

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

506 {
507  if (_elements[e->id()])
508  this->delete_elem(_elements[e->id()]);
509 
510 #ifdef LIBMESH_ENABLE_UNIQUE_ID
511  if (!e->valid_unique_id())
512  {
513  if (processor_id() == e->processor_id())
514  {
515  e->set_unique_id() = _next_unique_id;
516  _next_unique_id += this->n_processors() + 1;
517  }
518  else
519  {
520  e->set_unique_id() = _next_unpartitioned_unique_id;
522  }
523  }
524 #endif
525 
526  // Try to make the cached elem data more accurate
527  processor_id_type elem_procid = e->processor_id();
528  if (elem_procid == this->processor_id() ||
529  elem_procid == DofObject::invalid_processor_id)
530  _n_elem++;
531 
532  _elements[e->id()] = e;
533 
534  return e;
535 }
mapvector< Elem *, dof_id_type > _elements
processor_id_type n_processors() const
uint8_t processor_id_type
Definition: id_types.h:99
unique_id_type _next_unique_id
Definition: mesh_base.h:1349
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
unique_id_type _next_unpartitioned_unique_id
virtual void delete_elem(Elem *e) libmesh_override
processor_id_type processor_id() const
Node * libMesh::DistributedMesh::insert_node ( Node n)
virtualinherited

Calls add_node().

Implements libMesh::MeshBase.

Definition at line 703 of file distributed_mesh.C.

References libMesh::DistributedMesh::add_node().

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

704 {
705  return DistributedMesh::add_node(n);
706 }
virtual Node * add_node(Node *n) libmesh_override
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 130 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

Referenced by libMesh::DofMap::build_sparsity(), libMesh::DofMap::create_dof_constraints(), libMesh::DofMap::distribute_dofs(), and libMesh::DofMap::reinit().

131  { return _is_prepared; }
virtual bool libMesh::DistributedMesh::is_serial ( ) const
inlinevirtualinherited
Returns
true if all elements and nodes of the mesh exist on the current processor, false otherwise

Reimplemented from libMesh::MeshBase.

Definition at line 121 of file distributed_mesh.h.

References libMesh::DistributedMesh::_is_serial.

Referenced by libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshCommunication::redistribute(), and libMesh::DistributedMesh::redistribute().

122  { return _is_serial; }
virtual bool libMesh::DistributedMesh::is_serial_on_zero ( ) const
inlinevirtualinherited
Returns
true if all elements and nodes of the mesh exist on the processor 0, false otherwise

Reimplemented from libMesh::MeshBase.

Definition at line 128 of file distributed_mesh.h.

References libMesh::DistributedMesh::_is_serial, and libMesh::DistributedMesh::_is_serial_on_proc_0.

virtual element_iterator libMesh::DistributedMesh::level_elements_begin ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::level_elements_begin ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::level_elements_end ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::level_elements_end ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags ( ) const
inherited

Verify refinement_flag and p_refinement_flag consistency of our elements containers. Calls libmesh_assert() on each possible failure.

Definition at line 953 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::Elem::active(), libMesh::ParallelObject::comm(), libMesh::invalid_uint, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::Elem::p_refinement_flag(), libMesh::DistributedMesh::parallel_max_elem_id(), and libMesh::Elem::refinement_flag().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::is_replicated(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

954 {
955 #if defined(LIBMESH_ENABLE_AMR) && !defined(NDEBUG)
956  // This function must be run on all processors at once
957  parallel_object_only();
958 
959  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
960 
961  for (dof_id_type i=0; i != pmax_elem_id; ++i)
962  {
963  Elem * el = _elements[i]; // Returns NULL if there's no map entry
964 
965  unsigned int refinement_flag = el ?
966  static_cast<unsigned int> (el->refinement_flag()) : libMesh::invalid_uint;
967  unsigned int p_refinement_flag = el ?
968  static_cast<unsigned int> (el->p_refinement_flag()) : libMesh::invalid_uint;
969 
970  libmesh_assert(this->comm().semiverify(el ? &refinement_flag : libmesh_nullptr));
971 
972  // p refinement flags aren't always kept correct on inactive
973  // ghost elements
974  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_refinement_flag : libmesh_nullptr));
975  }
976 #endif // LIBMESH_ENABLE_AMR
977 }
mapvector< Elem *, dof_id_type > _elements
const unsigned int invalid_uint
Definition: libmesh.h:184
const class libmesh_nullptr_t libmesh_nullptr
dof_id_type parallel_max_elem_id() const
libmesh_assert(j)
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids ( ) const
virtualinherited

Verify id and processor_id consistency of our elements and nodes containers. Calls libmesh_assert() on each possible failure.

Reimplemented from libMesh::MeshBase.

Definition at line 922 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_nodes, and libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids().

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::is_replicated(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

923 {
926 }
mapvector< Elem *, dof_id_type > _elements
mapvector< Node *, dof_id_type > _nodes
void libmesh_assert_valid_parallel_object_ids(const mapvector< T *, dof_id_type > &) const
template<typename T >
void libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids ( const mapvector< T *, dof_id_type > &  objects) const
inherited

Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container. Calls libmesh_assert() on each possible failure in that container.

Definition at line 866 of file distributed_mesh.C.

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libmesh_nullptr, std::max(), libMesh::Parallel::Communicator::min(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DistributedMesh::is_replicated(), and libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids().

867 {
868  // This function must be run on all processors at once
869  parallel_object_only();
870 
871  const dof_id_type pmax_node_id = this->parallel_max_node_id();
872  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
873  const dof_id_type pmax_id = std::max(pmax_node_id, pmax_elem_id);
874 
875  for (dof_id_type i=0; i != pmax_id; ++i)
876  {
877  T * obj = objects[i]; // Returns NULL if there's no map entry
878 
879  // Local lookups by id should return the requested object
880  libmesh_assert(!obj || obj->id() == i);
881 
882  // All processors with an object should agree on id
883 #ifndef NDEBUG
884  const dof_id_type dofid = obj && obj->valid_id() ?
885  obj->id() : DofObject::invalid_id;
886  libmesh_assert(this->comm().semiverify(obj ? &dofid : libmesh_nullptr));
887 #endif
888 
889  // All processors with an object should agree on processor id
890  const dof_id_type procid = obj && obj->valid_processor_id() ?
891  obj->processor_id() : DofObject::invalid_processor_id;
892  libmesh_assert(this->comm().semiverify(obj ? &procid : libmesh_nullptr));
893 
894  dof_id_type min_procid = procid;
895  this->comm().min(min_procid);
896 
897  // Either:
898  // 1.) I own this elem (min_procid == this->processor_id()) *and* I have a valid pointer to it (obj != NULL)
899  // or
900  // 2.) I don't own this elem (min_procid != this->processor_id()). (In this case I may or may not have a valid pointer to it.)
901 
902  // Original assert logic
903  // libmesh_assert (min_procid != this->processor_id() || obj);
904 
905  // More human-understandable logic...
907  ((min_procid == this->processor_id()) && obj)
908  ||
909  (min_procid != this->processor_id())
910  );
911 
912 #if defined(LIBMESH_ENABLE_UNIQUE_ID) && !defined(NDEBUG)
913  // All processors with an object should agree on unique id
914  const unique_id_type uniqueid = obj ? obj->unique_id() : 0;
915  libmesh_assert(this->comm().semiverify(obj ? &uniqueid : libmesh_nullptr));
916 #endif
917  }
918 }
const class libmesh_nullptr_t libmesh_nullptr
dof_id_type parallel_max_elem_id() const
long double max(long double a, double b)
libmesh_assert(j)
dof_id_type parallel_max_node_id() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
static const dof_id_type invalid_id
Definition: dof_object.h:334
const Parallel::Communicator & comm() const
uint8_t unique_id_type
Definition: id_types.h:79
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels ( ) const
inherited

Verify p_level consistency of our elements containers. Calls libmesh_assert() on each possible failure.

Definition at line 930 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::Elem::active(), libMesh::ParallelObject::comm(), libMesh::invalid_uint, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::Elem::p_level(), and libMesh::DistributedMesh::parallel_max_elem_id().

Referenced by libMesh::DistributedMesh::is_replicated(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

931 {
932 #ifndef NDEBUG
933  // This function must be run on all processors at once
934  parallel_object_only();
935 
936  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
937 
938  for (dof_id_type i=0; i != pmax_elem_id; ++i)
939  {
940  Elem * el = _elements[i]; // Returns NULL if there's no map entry
941 
942  unsigned int p_level = el ? (el->p_level()) : libMesh::invalid_uint;
943 
944  // All processors with an active element should agree on p level
945  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_level : libmesh_nullptr));
946  }
947 #endif
948 }
mapvector< Elem *, dof_id_type > _elements
const unsigned int invalid_uint
Definition: libmesh.h:184
const class libmesh_nullptr_t libmesh_nullptr
dof_id_type parallel_max_elem_id() const
libmesh_assert(j)
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
virtual element_iterator libMesh::DistributedMesh::local_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::local_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::local_level_elements_begin ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_level_elements_begin ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::local_level_elements_end ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_level_elements_end ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::local_nodes_begin ( )
virtualinherited

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

Implements libMesh::MeshBase.

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

virtual const_node_iterator libMesh::DistributedMesh::local_nodes_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual node_iterator libMesh::DistributedMesh::local_nodes_end ( )
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::local_nodes_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_begin ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_not_level_elements_begin ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_end ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::local_not_level_elements_end ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual dof_id_type libMesh::DistributedMesh::max_elem_id ( ) const
inlinevirtualinherited
virtual dof_id_type libMesh::DistributedMesh::max_node_id ( ) const
inlinevirtualinherited
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 147 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshTools::Generation::build_sphere(), libMesh::EquationSystems::build_variable_names(), libMesh::MeshBase::cache_elem_dims(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshTools::Modification::distort(), libMesh::ExactErrorEstimator::estimate_error(), 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::FEInterface::n_vec_dim(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::GMVIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::HPCoarsenTest::select_refinement(), libMesh::MeshTools::Modification::smooth(), libMesh::DofMap::use_coupled_neighbor_dofs(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UCDIO::write_nodal_data(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), and libMesh::EnsightIO::write_vector_ascii().

148 {
149  if (!_elem_dims.empty())
150  return cast_int<unsigned int>(*_elem_dims.rbegin());
151  return 0;
152 }
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1384
dof_id_type libMesh::DistributedMesh::n_active_elem ( ) const
virtualinherited
Returns
The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

Definition at line 1333 of file distributed_mesh.C.

References libMesh::DistributedMesh::active_local_elements_begin(), libMesh::DistributedMesh::active_local_elements_end(), libMesh::DistributedMesh::active_pid_elements_begin(), libMesh::DistributedMesh::active_pid_elements_end(), libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, and libMesh::Parallel::Communicator::sum().

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

1334 {
1335  parallel_object_only();
1336 
1337  // Get local active elements first
1338  dof_id_type active_elements =
1339  static_cast<dof_id_type>(std::distance (this->active_local_elements_begin(),
1340  this->active_local_elements_end()));
1341  this->comm().sum(active_elements);
1342 
1343  // Then add unpartitioned active elements, which should exist on
1344  // every processor
1345  active_elements +=
1346  static_cast<dof_id_type>(std::distance
1349  return active_elements;
1350 }
virtual element_iterator active_local_elements_begin() libmesh_override
virtual element_iterator active_local_elements_end() libmesh_override
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
virtual element_iterator active_pid_elements_begin(processor_id_type proc_id) libmesh_override
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
virtual element_iterator active_pid_elements_end(processor_id_type proc_id) libmesh_override
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 374 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(), and libMesh::MeshBase::n_unpartitioned_elem().

375 {
376  libmesh_assert_less (proc_id, this->n_processors());
377  return static_cast<dof_id_type>(std::distance (this->active_pid_elements_begin(proc_id),
378  this->active_pid_elements_end (proc_id)));
379 }
processor_id_type n_processors() const
virtual element_iterator active_pid_elements_begin(processor_id_type proc_id)=0
virtual element_iterator active_pid_elements_end(processor_id_type proc_id)=0
uint8_t dof_id_type
Definition: id_types.h:64
dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const
inlineinherited
dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const
inherited

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

Definition at line 398 of file mesh_base.C.

References libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), and end.

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

399 {
400  dof_id_type ne=0;
401 
402  const_element_iterator el = this->active_elements_begin();
403  const const_element_iterator end = this->active_elements_end();
404 
405  for (; el!=end; ++el)
406  ne += (*el)->n_sub_elem();
407 
408  return ne;
409 }
IterBase * end
virtual element_iterator active_elements_begin()=0
virtual element_iterator active_elements_end()=0
uint8_t dof_id_type
Definition: id_types.h:64
virtual dof_id_type libMesh::DistributedMesh::n_elem ( ) const
inlinevirtualinherited
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 224 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_elem, and libMesh::DistributedMesh::n_active_elem().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshCommunication::gather(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

224 { return _n_elem; }
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 361 of file mesh_base.C.

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

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

362 {
363  // We're either counting a processor's elements or unpartitioned
364  // elements
365  libmesh_assert (proc_id < this->n_processors() ||
367 
368  return static_cast<dof_id_type>(std::distance (this->pid_elements_begin(proc_id),
369  this->pid_elements_end (proc_id)));
370 }
processor_id_type n_processors() const
libmesh_assert(j)
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
virtual element_iterator pid_elements_begin(processor_id_type proc_id)=0
uint8_t dof_id_type
Definition: id_types.h:64
virtual element_iterator pid_elements_end(processor_id_type proc_id)=0
dof_id_type libMesh::MeshBase::n_local_elem ( ) const
inlineinherited
Returns
The number of elements on the local processor.

Definition at line 369 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().

370  { return this->n_elem_on_proc (this->processor_id()); }
dof_id_type n_elem_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:361
processor_id_type processor_id() const
dof_id_type libMesh::MeshBase::n_local_nodes ( ) const
inlineinherited
Returns
The number of nodes on the local processor.

Definition at line 269 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().

270  { return this->n_nodes_on_proc (this->processor_id()); }
dof_id_type n_nodes_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:348
processor_id_type processor_id() const
virtual dof_id_type libMesh::DistributedMesh::n_nodes ( ) const
inlinevirtualinherited
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 221 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_nodes.

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshCommunication::gather(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

221 { return _n_nodes; }
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 348 of file mesh_base.C.

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

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

349 {
350  // We're either counting a processor's nodes or unpartitioned
351  // nodes
352  libmesh_assert (proc_id < this->n_processors() ||
354 
355  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
356  this->pid_nodes_end (proc_id)));
357 }
virtual node_iterator pid_nodes_end(processor_id_type proc_id)=0
processor_id_type n_processors() const
libmesh_assert(j)
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
virtual node_iterator pid_nodes_begin(processor_id_type proc_id)=0
uint8_t dof_id_type
Definition: id_types.h:64
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 818 of file mesh_base.h.

References libMesh::MeshBase::_n_parts, libMesh::MeshBase::all_first_order(), libMesh::MeshBase::all_second_order(), libMesh::MeshBase::get_info(), libmesh_nullptr, libMesh::Quality::name(), libMesh::MeshBase::operator<<, libMesh::out, libMesh::MeshBase::print_info(), libMesh::MeshBase::read(), and libMesh::MeshBase::write().

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().

819  { return _n_parts; }
unsigned int _n_parts
Definition: mesh_base.h:1315
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), 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::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:722
const Parallel::Communicator & _communicator
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 383 of file mesh_base.C.

References libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), and end.

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

384 {
385  dof_id_type ne=0;
386 
387  const_element_iterator el = this->elements_begin();
388  const const_element_iterator end = this->elements_end();
389 
390  for (; el!=end; ++el)
391  ne += (*el)->n_sub_elem();
392 
393  return ne;
394 }
IterBase * end
virtual element_iterator elements_begin()=0
virtual element_iterator elements_end()=0
uint8_t dof_id_type
Definition: id_types.h:64
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 333 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

334 {
335  // This requires an inspection on every processor
336  parallel_object_only();
337 
338  std::set<subdomain_id_type> ids;
339 
340  this->subdomain_ids (ids);
341 
342  return cast_int<subdomain_id_type>(ids.size());
343 }
void subdomain_ids(std::set< subdomain_id_type > &ids) const
Definition: mesh_base.C:314
dof_id_type libMesh::MeshBase::n_unpartitioned_elem ( ) const
inlineinherited
Returns
The number of elements owned by no processor.

Definition at line 375 of file mesh_base.h.

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

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

dof_id_type n_elem_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:361
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
dof_id_type libMesh::MeshBase::n_unpartitioned_nodes ( ) const
inlineinherited
Returns
The number of nodes owned by no processor.

Definition at line 275 of file mesh_base.h.

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

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

dof_id_type n_nodes_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:348
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
unique_id_type libMesh::MeshBase::next_unique_id ( )
inlineinherited
Returns
The next unique id to be used.

Definition at line 288 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

288 { return _next_unique_id; }
unique_id_type _next_unique_id
Definition: mesh_base.h:1349
virtual const Node& libMesh::MeshBase::node ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A constant reference (for reading only) to the $ i^{th} $ 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 436 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::MeshBase::cache_elem_dims(), and libMesh::MeshTools::Modification::change_boundary_id().

437  {
438  libmesh_deprecated();
439  return *this->node_ptr(i);
440  }
virtual const Node * node_ptr(const dof_id_type i) const =0
virtual Node& libMesh::MeshBase::node ( const dof_id_type  i)
inlinevirtualinherited
Returns
A reference to the $ i^{th} $ 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 448 of file mesh_base.h.

References libMesh::MeshBase::node_ptr(), and libMesh::MeshBase::query_node_ptr().

449  {
450  libmesh_deprecated();
451  return *this->node_ptr(i);
452  }
virtual const Node * node_ptr(const dof_id_type i) const =0
const Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i) const
virtualinherited
Returns
A pointer to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 301 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, and libMesh::libmesh_assert().

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

302 {
304  libmesh_assert_equal_to (_nodes[i]->id(), i);
305 
306  return _nodes[i];
307 }
libmesh_assert(j)
mapvector< Node *, dof_id_type > _nodes
Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i)
virtualinherited
Returns
A writable pointer to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 312 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, and libMesh::libmesh_assert().

313 {
315  libmesh_assert_equal_to (_nodes[i]->id(), i);
316 
317  return _nodes[i];
318 }
libmesh_assert(j)
mapvector< Node *, dof_id_type > _nodes
virtual const Node& libMesh::MeshBase::node_ref ( const dof_id_type  i) const
inlinevirtualinherited
virtual Node& libMesh::MeshBase::node_ref ( const dof_id_type  i)
inlinevirtualinherited
Returns
A reference to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.

Definition at line 425 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

425  {
426  return *this->node_ptr(i);
427  }
virtual const Node * node_ptr(const dof_id_type i) const =0
virtual node_iterator libMesh::DistributedMesh::nodes_begin ( )
virtualinherited
virtual const_node_iterator libMesh::DistributedMesh::nodes_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual const_node_iterator libMesh::DistributedMesh::nodes_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_active_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_active_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_level_elements_begin ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_level_elements_begin ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_level_elements_end ( unsigned int  level)
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_level_elements_end ( unsigned int  level) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_local_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_local_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( ) const
virtualinherited

Implements libMesh::MeshBase.

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( )
virtualinherited
virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( ) const
virtualinherited

Implements libMesh::MeshBase.

dof_id_type libMesh::DistributedMesh::parallel_max_elem_id ( ) const
inherited

Definition at line 206 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::ParallelObject::comm(), and libMesh::Parallel::Communicator::max().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::reserve_elem(), and libMesh::DistributedMesh::update_parallel_id_counts().

207 {
208  // This function must be run on all processors at once
209  parallel_object_only();
210 
211  dof_id_type max_local = 0;
212 
213  mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
214  rit = _elements.rbegin();
215 
216  const mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
217  rend = _elements.rend();
218 
219  // Look for the maximum element id. Search backwards through
220  // elements so we can break out early. Beware of NULL entries that
221  // haven't yet been cleared from _elements.
222  for (; rit != rend; ++rit)
223  if (rit->second)
224  {
225  libmesh_assert_equal_to(rit->second->id(), rit->first);
226  max_local = rit->first + 1;
227  break;
228  }
229 
230  this->comm().max(max_local);
231  return max_local;
232 }
mapvector< Elem *, dof_id_type > _elements
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
dof_id_type libMesh::DistributedMesh::parallel_max_node_id ( ) const
inherited

Definition at line 264 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, libMesh::ParallelObject::comm(), and libMesh::Parallel::Communicator::max().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::reserve_elem(), and libMesh::DistributedMesh::update_parallel_id_counts().

265 {
266  // This function must be run on all processors at once
267  parallel_object_only();
268 
269  dof_id_type max_local = 0;
270 
271  mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
272  rit = _nodes.rbegin();
273 
274  const mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
275  rend = _nodes.rend();
276 
277  // Look for the maximum element id. Search backwards through
278  // elements so we can break out early. Beware of NULL entries that
279  // haven't yet been cleared from _elements.
280  for (; rit != rend; ++rit)
281  if (rit->second)
282  {
283  libmesh_assert_equal_to(rit->second->id(), rit->first);
284  max_local = rit->first + 1;
285  break;
286  }
287 
288  this->comm().max(max_local);
289  return max_local;
290 }
mapvector< Node *, dof_id_type > _nodes
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
unique_id_type libMesh::DistributedMesh::parallel_max_unique_id ( ) const
virtualinherited
Returns
A number greater than or equal to the maximum unique_id in the mesh.

Implements libMesh::MeshBase.

Definition at line 237 of file distributed_mesh.C.

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

Referenced by libMesh::DistributedMesh::reserve_elem(), and libMesh::DistributedMesh::update_parallel_id_counts().

238 {
239  // This function must be run on all processors at once
240  parallel_object_only();
241 
244  this->comm().max(max_local);
245  return max_local;
246 }
long double max(long double a, double b)
unique_id_type _next_unique_id
Definition: mesh_base.h:1349
const Parallel::Communicator & comm() const
unique_id_type _next_unpartitioned_unique_id
uint8_t unique_id_type
Definition: id_types.h:79
dof_id_type libMesh::DistributedMesh::parallel_n_elem ( ) const
virtualinherited
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 193 of file distributed_mesh.C.

References libMesh::ParallelObject::comm(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_unpartitioned_elem(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::reserve_elem(), and libMesh::DistributedMesh::update_parallel_id_counts().

194 {
195  // This function must be run on all processors at once
196  parallel_object_only();
197 
198  dof_id_type n_local = this->n_local_elem();
199  this->comm().sum(n_local);
200  n_local += this->n_unpartitioned_elem();
201  return n_local;
202 }
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:375
dof_id_type n_local_elem() const
Definition: mesh_base.h:369
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64
dof_id_type libMesh::DistributedMesh::parallel_n_nodes ( ) const
virtualinherited
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 251 of file distributed_mesh.C.

References libMesh::ParallelObject::comm(), libMesh::MeshBase::n_local_nodes(), libMesh::MeshBase::n_unpartitioned_nodes(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::reserve_elem(), and libMesh::DistributedMesh::update_parallel_id_counts().

252 {
253