libMesh::ParallelMesh Class Reference

#include <parallel_mesh.h>

Inheritance diagram for libMesh::ParallelMesh:

Public Types

typedef Predicates::multi_predicate Predicate
 

Public Member Functions

 ParallelMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
 
 ParallelMesh (const UnstructuredMesh &other_mesh)
 
virtual std::unique_ptr< MeshBaseclone () const override
 
 ~ParallelMesh ()
 
virtual void clear () override
 
virtual void redistribute () override
 
virtual void update_post_partitioning () override
 
virtual bool is_serial () const override
 
virtual bool is_serial_on_zero () const override
 
virtual void set_distributed () override
 
virtual bool is_replicated () const 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 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 () override
 
virtual void allgather () override
 
virtual void gather_to_zero () override
 
virtual void delete_remote_elements () override
 
virtual void add_extra_ghost_elem (Elem *e)
 
virtual void clear_extra_ghost_elems ()
 
virtual dof_id_type n_nodes () const override
 
virtual dof_id_type max_node_id () const override
 
virtual void reserve_nodes (const dof_id_type) override
 
virtual dof_id_type n_elem () const override
 
virtual dof_id_type n_active_elem () const override
 
virtual dof_id_type max_elem_id () const override
 
virtual void reserve_elem (const dof_id_type) override
 
virtual void update_parallel_id_counts () override
 
virtual dof_id_type parallel_n_nodes () const override
 
dof_id_type parallel_max_node_id () const
 
virtual dof_id_type parallel_n_elem () const override
 
dof_id_type parallel_max_elem_id () const
 
virtual unique_id_type parallel_max_unique_id () const override
 
virtual const Pointpoint (const dof_id_type i) const override
 
virtual const Nodenode_ptr (const dof_id_type i) const override
 
virtual Nodenode_ptr (const dof_id_type i) override
 
virtual const Nodequery_node_ptr (const dof_id_type i) const override
 
virtual Nodequery_node_ptr (const dof_id_type i) override
 
virtual const Elemelem_ptr (const dof_id_type i) const override
 
virtual Elemelem_ptr (const dof_id_type i) override
 
virtual const Elemquery_elem_ptr (const dof_id_type i) const override
 
virtual Elemquery_elem_ptr (const dof_id_type i) 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) override
 
virtual Nodeadd_node (Node *n) override
 
virtual Nodeinsert_node (Node *n) override
 
virtual void own_node (Node &n) override
 
virtual void delete_node (Node *n) override
 
virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) override
 
virtual Elemadd_elem (Elem *e) override
 
virtual Eleminsert_elem (Elem *e) override
 
virtual void delete_elem (Elem *e) override
 
virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) override
 
virtual void fix_broken_node_and_element_numbering () override
 
virtual element_iterator elements_begin () override
 
virtual const_element_iterator elements_begin () const override
 
virtual element_iterator elements_end () override
 
virtual const_element_iterator elements_end () const override
 
virtual SimpleRange< element_iteratorelement_ptr_range () override
 
virtual SimpleRange< const_element_iteratorelement_ptr_range () const override
 
virtual element_iterator active_elements_begin () override
 
virtual const_element_iterator active_elements_begin () const override
 
virtual element_iterator active_elements_end () override
 
virtual const_element_iterator active_elements_end () const override
 
virtual SimpleRange< element_iteratoractive_element_ptr_range () override
 
virtual SimpleRange< const_element_iteratoractive_element_ptr_range () const override
 
virtual element_iterator ancestor_elements_begin () override
 
virtual const_element_iterator ancestor_elements_begin () const override
 
virtual element_iterator ancestor_elements_end () override
 
virtual const_element_iterator ancestor_elements_end () const override
 
virtual element_iterator subactive_elements_begin () override
 
virtual const_element_iterator subactive_elements_begin () const override
 
virtual element_iterator subactive_elements_end () override
 
virtual const_element_iterator subactive_elements_end () const override
 
virtual element_iterator not_active_elements_begin () override
 
virtual const_element_iterator not_active_elements_begin () const override
 
virtual element_iterator not_active_elements_end () override
 
virtual const_element_iterator not_active_elements_end () const override
 
virtual element_iterator not_ancestor_elements_begin () override
 
virtual const_element_iterator not_ancestor_elements_begin () const override
 
virtual element_iterator not_ancestor_elements_end () override
 
virtual const_element_iterator not_ancestor_elements_end () const override
 
virtual element_iterator not_subactive_elements_begin () override
 
virtual const_element_iterator not_subactive_elements_begin () const override
 
virtual element_iterator not_subactive_elements_end () override
 
virtual const_element_iterator not_subactive_elements_end () const override
 
virtual element_iterator local_elements_begin () override
 
virtual const_element_iterator local_elements_begin () const override
 
virtual element_iterator local_elements_end () override
 
virtual const_element_iterator local_elements_end () const override
 
virtual element_iterator semilocal_elements_begin () override
 
virtual const_element_iterator semilocal_elements_begin () const override
 
virtual element_iterator semilocal_elements_end () override
 
virtual const_element_iterator semilocal_elements_end () const override
 
virtual element_iterator active_semilocal_elements_begin () override
 
virtual const_element_iterator active_semilocal_elements_begin () const override
 
virtual element_iterator active_semilocal_elements_end () override
 
virtual const_element_iterator active_semilocal_elements_end () const override
 
virtual element_iterator facelocal_elements_begin () override
 
virtual const_element_iterator facelocal_elements_begin () const override
 
virtual element_iterator facelocal_elements_end () override
 
virtual const_element_iterator facelocal_elements_end () const override
 
virtual element_iterator not_local_elements_begin () override
 
virtual const_element_iterator not_local_elements_begin () const override
 
virtual element_iterator not_local_elements_end () override
 
virtual const_element_iterator not_local_elements_end () const override
 
virtual element_iterator active_local_elements_begin () override
 
virtual const_element_iterator active_local_elements_begin () const override
 
virtual element_iterator active_local_elements_end () override
 
virtual const_element_iterator active_local_elements_end () const override
 
virtual SimpleRange< element_iteratoractive_local_element_ptr_range () override
 
virtual SimpleRange< const_element_iteratoractive_local_element_ptr_range () const override
 
virtual element_iterator active_not_local_elements_begin () override
 
virtual const_element_iterator active_not_local_elements_begin () const override
 
virtual element_iterator active_not_local_elements_end () override
 
virtual const_element_iterator active_not_local_elements_end () const override
 
virtual element_iterator level_elements_begin (unsigned int level) override
 
virtual const_element_iterator level_elements_begin (unsigned int level) const override
 
virtual element_iterator level_elements_end (unsigned int level) override
 
virtual const_element_iterator level_elements_end (unsigned int level) const override
 
virtual element_iterator not_level_elements_begin (unsigned int level) override
 
virtual const_element_iterator not_level_elements_begin (unsigned int level) const override
 
virtual element_iterator not_level_elements_end (unsigned int level) override
 
virtual const_element_iterator not_level_elements_end (unsigned int level) const override
 
virtual element_iterator local_level_elements_begin (unsigned int level) override
 
virtual const_element_iterator local_level_elements_begin (unsigned int level) const override
 
virtual element_iterator local_level_elements_end (unsigned int level) override
 
virtual const_element_iterator local_level_elements_end (unsigned int level) const override
 
virtual element_iterator local_not_level_elements_begin (unsigned int level) override
 
virtual const_element_iterator local_not_level_elements_begin (unsigned int level) const override
 
virtual element_iterator local_not_level_elements_end (unsigned int level) override
 
virtual const_element_iterator local_not_level_elements_end (unsigned int level) const override
 
virtual element_iterator pid_elements_begin (processor_id_type proc_id) override
 
virtual const_element_iterator pid_elements_begin (processor_id_type proc_id) const override
 
virtual element_iterator pid_elements_end (processor_id_type proc_id) override
 
virtual const_element_iterator pid_elements_end (processor_id_type proc_id) const override
 
virtual element_iterator type_elements_begin (ElemType type) override
 
virtual const_element_iterator type_elements_begin (ElemType type) const override
 
virtual element_iterator type_elements_end (ElemType type) override
 
virtual const_element_iterator type_elements_end (ElemType type) const override
 
virtual element_iterator active_type_elements_begin (ElemType type) override
 
virtual const_element_iterator active_type_elements_begin (ElemType type) const override
 
virtual element_iterator active_type_elements_end (ElemType type) override
 
virtual const_element_iterator active_type_elements_end (ElemType type) const override
 
virtual element_iterator active_pid_elements_begin (processor_id_type proc_id) override
 
virtual const_element_iterator active_pid_elements_begin (processor_id_type proc_id) const override
 
virtual element_iterator active_pid_elements_end (processor_id_type proc_id) override
 
virtual const_element_iterator active_pid_elements_end (processor_id_type proc_id) const override
 
virtual element_iterator unpartitioned_elements_begin () override
 
virtual const_element_iterator unpartitioned_elements_begin () const override
 
virtual element_iterator unpartitioned_elements_end () override
 
virtual const_element_iterator unpartitioned_elements_end () const override
 
virtual element_iterator active_unpartitioned_elements_begin () override
 
virtual const_element_iterator active_unpartitioned_elements_begin () const override
 
virtual element_iterator active_unpartitioned_elements_end () override
 
virtual const_element_iterator active_unpartitioned_elements_end () const override
 
virtual element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) override
 
virtual const_element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
 
virtual element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) override
 
virtual const_element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const override
 
virtual element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) override
 
virtual const_element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
 
virtual element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) override
 
virtual const_element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) const override
 
virtual element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) override
 
virtual const_element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) const override
 
virtual element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) override
 
virtual const_element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) const override
 
virtual element_iterator ghost_elements_begin () override
 
virtual const_element_iterator ghost_elements_begin () const override
 
virtual element_iterator ghost_elements_end () override
 
virtual const_element_iterator ghost_elements_end () const override
 
virtual element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
 
virtual const_element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
 
virtual element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
 
virtual const_element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
 
virtual element_iterator flagged_elements_begin (unsigned char rflag) override
 
virtual const_element_iterator flagged_elements_begin (unsigned char rflag) const override
 
virtual element_iterator flagged_elements_end (unsigned char rflag) override
 
virtual const_element_iterator flagged_elements_end (unsigned char rflag) const override
 
virtual element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) override
 
virtual const_element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) const override
 
virtual element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) override
 
virtual const_element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) const override
 
virtual node_iterator nodes_begin () override
 
virtual const_node_iterator nodes_begin () const override
 
virtual node_iterator nodes_end () override
 
virtual const_node_iterator nodes_end () const override
 
virtual SimpleRange< node_iteratornode_ptr_range () override
 
virtual SimpleRange< const_node_iteratornode_ptr_range () const override
 
virtual node_iterator active_nodes_begin () override
 
virtual const_node_iterator active_nodes_begin () const override
 
virtual node_iterator active_nodes_end () override
 
virtual const_node_iterator active_nodes_end () const override
 
virtual node_iterator local_nodes_begin () override
 
virtual const_node_iterator local_nodes_begin () const override
 
virtual node_iterator local_nodes_end () override
 
virtual const_node_iterator local_nodes_end () const override
 
virtual SimpleRange< node_iteratorlocal_node_ptr_range () override
 
virtual SimpleRange< const_node_iteratorlocal_node_ptr_range () const override
 
virtual node_iterator pid_nodes_begin (processor_id_type proc_id) override
 
virtual const_node_iterator pid_nodes_begin (processor_id_type proc_id) const override
 
virtual node_iterator pid_nodes_end (processor_id_type proc_id) override
 
virtual const_node_iterator pid_nodes_end (processor_id_type proc_id) const override
 
virtual node_iterator bid_nodes_begin (boundary_id_type bndry_id) override
 
virtual const_node_iterator bid_nodes_begin (boundary_id_type bndry_id) const override
 
virtual node_iterator bid_nodes_end (boundary_id_type bndry_id) override
 
virtual const_node_iterator bid_nodes_end (boundary_id_type bndry_id) const override
 
virtual node_iterator bnd_nodes_begin () override
 
virtual const_node_iterator bnd_nodes_begin () const override
 
virtual node_iterator bnd_nodes_end () override
 
virtual const_node_iterator bnd_nodes_end () const override
 
virtual node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
 
virtual const_node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
 
virtual node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
 
virtual const_node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
 
virtual void read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) override
 
virtual void write (const std::string &name) override
 
void write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names)
 
virtual void all_first_order () override
 
virtual void all_second_order (const bool full_ordered=true) override
 
void create_pid_mesh (UnstructuredMesh &pid_mesh, const processor_id_type pid) const
 
void create_submesh (UnstructuredMesh &new_mesh, const const_element_iterator &it, const const_element_iterator &it_end) const
 
virtual void copy_nodes_and_elements (const UnstructuredMesh &other_mesh, const bool skip_find_neighbors=false, dof_id_type element_id_offset=0, dof_id_type node_id_offset=0, unique_id_type unique_id_offset=0)
 
virtual void find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) override
 
virtual bool contract () override
 
virtual std::unique_ptr< Partitioner > & partitioner ()
 
const 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
 
GhostingFunctordefault_ghosting ()
 
void subdomain_ids (std::set< subdomain_id_type > &ids) const
 
subdomain_id_type n_subdomains () const
 
unsigned int n_partitions () const
 
std::string get_info () const
 
void print_info (std::ostream &os=libMesh::out) const
 
unsigned int recalculate_n_partitions ()
 
const PointLocatorBasepoint_locator () const
 
std::unique_ptr< 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

std::unique_ptr< 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
 
std::unique_ptr< PointLocatorBase_point_locator
 
bool _count_lower_dim_elems_in_point_locator
 
std::unique_ptr< Partitioner_partitioner
 
unique_id_type _next_unique_id
 
bool _skip_partitioning
 
bool _skip_renumber_nodes_and_elements
 
bool _allow_remote_element_removal
 
std::map< subdomain_id_type, std::string > _block_id_to_name
 
std::set< unsigned char > _elem_dims
 
unsigned char _spatial_dimension
 
std::unique_ptr< GhostingFunctor_default_ghosting
 
std::set< GhostingFunctor * > _ghosting_functors
 
const Parallel::Communicator_communicator
 

Detailed Description

Definition at line 34 of file parallel_mesh.h.

Member Typedef Documentation

◆ Predicate

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

Definition at line 931 of file mesh_base.h.

Constructor & Destructor Documentation

◆ ParallelMesh() [1/2]

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

Definition at line 38 of file parallel_mesh.h.

40  : DistributedMesh(comm_in,dim) {}
DistributedMesh(const Parallel::Communicator &comm_in, unsigned char dim=1)

◆ ParallelMesh() [2/2]

libMesh::ParallelMesh::ParallelMesh ( const UnstructuredMesh other_mesh)
inline

Definition at line 42 of file parallel_mesh.h.

42 : DistributedMesh(other_mesh) {}
DistributedMesh(const Parallel::Communicator &comm_in, unsigned char dim=1)

◆ ~ParallelMesh()

libMesh::ParallelMesh::~ParallelMesh ( )
inline

Definition at line 47 of file parallel_mesh.h.

47 {}

Member Function Documentation

◆ active_element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_element_ptr_range ( )
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 305 of file distributed_mesh.h.

References libMesh::DistributedMesh::active_elements_begin(), and libMesh::DistributedMesh::active_elements_end().

virtual element_iterator active_elements_begin() override
virtual element_iterator active_elements_end() override

◆ active_element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_element_ptr_range ( ) const
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 306 of file distributed_mesh.h.

References libMesh::DistributedMesh::active_elements_begin(), and libMesh::DistributedMesh::active_elements_end().

virtual element_iterator active_elements_begin() override
virtual element_iterator active_elements_end() override

◆ active_elements_begin() [1/2]

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

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

◆ active_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ active_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_elements_end ( )
overridevirtualinherited

◆ active_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_local_element_ptr_range ( )
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 362 of file distributed_mesh.h.

References libMesh::DistributedMesh::active_local_elements_begin(), and libMesh::DistributedMesh::active_local_elements_end().

virtual element_iterator active_local_elements_end() override
virtual element_iterator active_local_elements_begin() override

◆ active_local_element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_local_element_ptr_range ( ) const
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 363 of file distributed_mesh.h.

References libMesh::DistributedMesh::active_local_elements_begin(), and libMesh::DistributedMesh::active_local_elements_end().

virtual element_iterator active_local_elements_end() override
virtual element_iterator active_local_elements_begin() override

◆ active_local_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_local_elements_begin ( )
overridevirtualinherited

◆ active_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_local_elements_end ( )
overridevirtualinherited

◆ active_local_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_subdomain_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_subdomain_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_subdomain_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_local_subdomain_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_nodes_begin() [1/2]

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

Iterate over only the active nodes in the Mesh.

Implements libMesh::MeshBase.

◆ active_nodes_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ active_nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::active_nodes_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_nodes_end() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::active_nodes_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_not_local_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_not_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_not_local_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_not_local_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_pid_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id)
overridevirtualinherited

◆ active_pid_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_pid_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id)
overridevirtualinherited

◆ active_pid_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_semilocal_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_semilocal_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_semilocal_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_semilocal_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_set_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type ss)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_set_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ active_subdomain_set_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type ss)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_subdomain_set_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ active_type_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_type_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_type_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_type_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_unpartitioned_elements_begin() [1/2]

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

Iterate over active unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

◆ active_unpartitioned_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ active_unpartitioned_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ active_unpartitioned_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ add_elem()

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

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

386 {
387  // Don't try to add nullptrs!
388  libmesh_assert(e);
389 
390  // Trying to add an existing element is a no-op
391  if (e->valid_id() && _elements[e->id()] == e)
392  return e;
393 
394  const processor_id_type elem_procid = e->processor_id();
395 
396  if (!e->valid_id())
397  {
398  // We should only be creating new ids past the end of the range
399  // of existing ids
400  libmesh_assert_greater_equal(_next_free_unpartitioned_elem_id,
401  _max_elem_id);
402  libmesh_assert_greater_equal(_next_free_local_elem_id, _max_elem_id);
403 
404  // Use the unpartitioned ids for unpartitioned elems, and
405  // temporarily for ghost elems
407  if (elem_procid == this->processor_id())
408  next_id = &_next_free_local_elem_id;
409  e->set_id (*next_id);
410  }
411 
412  {
413  // Advance next_ids up high enough that each is pointing to an
414  // unused id and any subsequent increments will still point us
415  // to unused ids
417  static_cast<dof_id_type>(e->id()+1));
418 
421  ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
422  (this->n_processors() + 1) + this->n_processors();
425  ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
426  (this->n_processors() + 1) + this->processor_id();
427 
428 #ifndef NDEBUG
429  // We need a const mapvector so we don't inadvertently create
430  // nullptr entries when testing for non-nullptr ones
431  const mapvector<Elem *, dof_id_type> & const_elements = _elements;
432 #endif
433  libmesh_assert(!const_elements[_next_free_unpartitioned_elem_id]);
434  libmesh_assert(!const_elements[_next_free_local_elem_id]);
435  }
436 
437  // Don't try to overwrite existing elems
438  libmesh_assert (!_elements[e->id()]);
439 
440  _elements[e->id()] = e;
441 
442  // Try to make the cached elem data more accurate
443  if (elem_procid == this->processor_id() ||
444  elem_procid == DofObject::invalid_processor_id)
445  _n_elem++;
446 
447 #ifdef LIBMESH_ENABLE_UNIQUE_ID
448  if (!e->valid_unique_id())
449  {
450  if (processor_id() == e->processor_id())
451  {
452  e->set_unique_id() = _next_unique_id;
453  _next_unique_id += this->n_processors() + 1;
454  }
455  else
456  {
457  e->set_unique_id() = _next_unpartitioned_unique_id;
459  }
460  }
461 #endif
462 
463  // Unpartitioned elems should be added on every processor
464  // And shouldn't be added in the same batch as ghost elems
465  // But we might be just adding on processor 0 to
466  // broadcast later
467  // #ifdef DEBUG
468  // if (elem_procid == DofObject::invalid_processor_id)
469  // {
470  // dof_id_type elem_id = e->id();
471  // this->comm().max(elem_id);
472  // libmesh_assert_equal_to (elem_id, e->id());
473  // }
474  // #endif
475 
476  return e;
477 }
mapvector< Elem *, dof_id_type > _elements
uint8_t processor_id_type
Definition: id_types.h:99
long double max(long double a, double b)
unique_id_type _next_unique_id
Definition: mesh_base.h:1418
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
dof_id_type _next_free_unpartitioned_elem_id
unique_id_type _next_unpartitioned_unique_id
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id
uint8_t dof_id_type
Definition: id_types.h:64

◆ add_extra_ghost_elem()

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

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

1408 {
1409  // First add the elem like normal
1410  add_elem(e);
1411 
1412  // Now add it to the set that won't be deleted when we call
1413  // delete_remote_elements()
1414  _extra_ghost_elems.insert(e);
1415 }
virtual Elem * add_elem(Elem *e) override
std::set< Elem * > _extra_ghost_elems

◆ add_ghosting_functor()

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

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

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

Definition at line 823 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

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

824  { _ghosting_functors.insert(&ghosting_functor); }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1475

◆ add_node()

Node * libMesh::DistributedMesh::add_node ( Node n)
overridevirtualinherited

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 596 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, 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::own_node().

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

◆ add_point()

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 
)
overridevirtualinherited

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 558 of file distributed_mesh.C.

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

561 {
562  auto n_it = _nodes.find(id);
563  if (n_it != _nodes.end().it)
564  {
565  Node * n = n_it->second;
566  libmesh_assert (n);
567  libmesh_assert_equal_to (n->id(), id);
568 
569  *n = p;
570  n->processor_id() = proc_id;
571 
572  return n;
573  }
574 
575  Node * n = Node::build(p, id).release();
576  n->processor_id() = proc_id;
577 
578  return DistributedMesh::add_node(n);
579 }
mapvector< Node *, dof_id_type > _nodes
static std::unique_ptr< Node > build(const Node &n)
Definition: node.h:304
virtual Node * add_node(Node *n) override

◆ all_first_order()

void libMesh::UnstructuredMesh::all_first_order ( )
overridevirtualinherited

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

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

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

Implements libMesh::MeshBase.

Definition at line 832 of file unstructured_mesh.C.

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

833 {
834  /*
835  * when the mesh is not prepared,
836  * at least renumber the nodes and
837  * elements, so that the node ids
838  * are correct
839  */
840  if (!this->_is_prepared)
842 
843  START_LOG("all_first_order()", "Mesh");
844 
848  std::vector<bool> node_touched_by_me(this->max_node_id(), false);
849 
850  // Loop over the high-ordered elements.
851  // First make sure they _are_ indeed high-order, and then replace
852  // them with an equivalent first-order element.
853  for (auto & so_elem : element_ptr_range())
854  {
855  libmesh_assert(so_elem);
856 
857  /*
858  * build the first-order equivalent, add to
859  * the new_elements list.
860  */
861  Elem * lo_elem = Elem::build
863  (so_elem->type()), so_elem->parent()).release();
864 
865  const unsigned short n_sides = so_elem->n_sides();
866 
867  for (unsigned short s=0; s != n_sides; ++s)
868  if (so_elem->neighbor_ptr(s) == remote_elem)
869  lo_elem->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
870 
871 #ifdef LIBMESH_ENABLE_AMR
872  /*
873  * Reset the parent links of any child elements
874  */
875  if (so_elem->has_children())
876  for (unsigned int c = 0, nc = so_elem->n_children(); c != nc; ++c)
877  {
878  Elem * child = so_elem->child_ptr(c);
879  child->set_parent(lo_elem);
880  lo_elem->add_child(child, c);
881  }
882 
883  /*
884  * Reset the child link of any parent element
885  */
886  if (so_elem->parent())
887  {
888  unsigned int c =
889  so_elem->parent()->which_child_am_i(so_elem);
890  lo_elem->parent()->replace_child(lo_elem, c);
891  }
892 
893  /*
894  * Copy as much data to the new element as makes sense
895  */
896  lo_elem->set_p_level(so_elem->p_level());
897  lo_elem->set_refinement_flag(so_elem->refinement_flag());
898  lo_elem->set_p_refinement_flag(so_elem->p_refinement_flag());
899 #endif
900 
901  libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());
902 
903  /*
904  * By definition the vertices of the linear and
905  * second order element are identically numbered.
906  * transfer these.
907  */
908  for (unsigned int v=0; v < so_elem->n_vertices(); v++)
909  {
910  lo_elem->set_node(v) = so_elem->node_ptr(v);
911  node_touched_by_me[lo_elem->node_id(v)] = true;
912  }
913 
914  /*
915  * find_neighbors relies on remote_elem neighbor links being
916  * properly maintained.
917  */
918  for (unsigned short s=0; s != n_sides; s++)
919  {
920  if (so_elem->neighbor_ptr(s) == remote_elem)
921  lo_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
922  }
923 
931  (this->get_boundary_info(), so_elem, lo_elem);
932 
933  /*
934  * The new first-order element is ready.
935  * Inserting it into the mesh will replace and delete
936  * the second-order element.
937  */
938  lo_elem->set_id(so_elem->id());
939 #ifdef LIBMESH_ENABLE_UNIQUE_ID
940  lo_elem->set_unique_id() = so_elem->unique_id();
941 #endif
942  lo_elem->processor_id() = so_elem->processor_id();
943  lo_elem->subdomain_id() = so_elem->subdomain_id();
944  this->insert_elem(lo_elem);
945  }
946 
947  // Deleting nodes does not invalidate iterators, so this is safe.
948  for (const auto & node : this->node_ptr_range())
949  if (!node_touched_by_me[node->id()])
950  this->delete_node(node);
951 
952  // If crazy people applied boundary info to non-vertices and then
953  // deleted those non-vertices, we should make sure their boundary id
954  // caches are correct.
956 
957  STOP_LOG("all_first_order()", "Mesh");
958 
959  // On hanging nodes that used to also be second order nodes, we
960  // might now have an invalid nodal processor_id()
962 
963  // delete or renumber nodes if desired
964  this->prepare_for_use();
965 }
static void set_node_processor_ids(MeshBase &mesh)
Definition: partitioner.C:679
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
virtual SimpleRange< element_iterator > element_ptr_range()=0
dof_id_type id() const
Definition: dof_object.h:655
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:245
virtual SimpleRange< node_iterator > node_ptr_range()=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:152
virtual const Node & node(const dof_id_type i) const
Definition: mesh_base.h:454
virtual Elem * insert_elem(Elem *e)=0
void copy_boundary_ids(const BoundaryInfo &old_boundary_info, const Elem *const old_elem, const Elem *const new_elem)
virtual dof_id_type max_node_id() const =0
static ElemType first_order_equivalent_type(const ElemType et)
Definition: elem.C:2584
virtual void renumber_nodes_and_elements()=0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ all_second_order()

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

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

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

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

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

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

Implements libMesh::MeshBase.

Definition at line 969 of file unstructured_mesh.C.

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

970 {
971  // This function must be run on all processors at once
972  parallel_object_only();
973 
974  /*
975  * when the mesh is not prepared,
976  * at least renumber the nodes and
977  * elements, so that the node ids
978  * are correct
979  */
980  if (!this->_is_prepared)
982 
983  /*
984  * If the mesh is empty
985  * then we have nothing to do
986  */
987  if (!this->n_elem())
988  return;
989 
990  /*
991  * If the mesh is already second order
992  * then we have nothing to do.
993  * We have to test for this in a round-about way to avoid
994  * a bug on distributed parallel meshes with more processors
995  * than elements.
996  */
997  bool already_second_order = false;
998  if (this->elements_begin() != this->elements_end() &&
999  (*(this->elements_begin()))->default_order() != FIRST)
1000  already_second_order = true;
1001  this->comm().max(already_second_order);
1002  if (already_second_order)
1003  return;
1004 
1005  START_LOG("all_second_order()", "Mesh");
1006 
1007  /*
1008  * this map helps in identifying second order
1009  * nodes. Namely, a second-order node:
1010  * - edge node
1011  * - face node
1012  * - bubble node
1013  * is uniquely defined through a set of adjacent
1014  * vertices. This set of adjacent vertices is
1015  * used to identify already added higher-order
1016  * nodes. We are safe to use node id's since we
1017  * make sure that these are correctly numbered.
1018  */
1019  std::map<std::vector<dof_id_type>, Node *> adj_vertices_to_so_nodes;
1020 
1021  /*
1022  * for speed-up of the \p add_point() method, we
1023  * can reserve memory. Guess the number of additional
1024  * nodes for different dimensions
1025  */
1026  switch (this->mesh_dimension())
1027  {
1028  case 1:
1029  /*
1030  * in 1D, there can only be order-increase from Edge2
1031  * to Edge3. Something like 1/2 of n_nodes() have
1032  * to be added
1033  */
1034  this->reserve_nodes(static_cast<unsigned int>
1035  (1.5*static_cast<double>(this->n_nodes())));
1036  break;
1037 
1038  case 2:
1039  /*
1040  * in 2D, either refine from Tri3 to Tri6 (double the nodes)
1041  * or from Quad4 to Quad8 (again, double) or Quad9 (2.25 that much)
1042  */
1043  this->reserve_nodes(static_cast<unsigned int>
1044  (2*static_cast<double>(this->n_nodes())));
1045  break;
1046 
1047 
1048  case 3:
1049  /*
1050  * in 3D, either refine from Tet4 to Tet10 (factor = 2.5) up to
1051  * Hex8 to Hex27 (something > 3). Since in 3D there _are_ already
1052  * quite some nodes, and since we do not want to overburden the memory by
1053  * a too conservative guess, use the lower bound
1054  */
1055  this->reserve_nodes(static_cast<unsigned int>
1056  (2.5*static_cast<double>(this->n_nodes())));
1057  break;
1058 
1059  default:
1060  // Hm?
1061  libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
1062  }
1063 
1064 
1065 
1066  /*
1067  * form a vector that will hold the node id's of
1068  * the vertices that are adjacent to the son-th
1069  * second-order node. Pull this outside of the
1070  * loop so that silly compilers don't repeatedly
1071  * create and destroy the vector.
1072  */
1073  std::vector<dof_id_type> adjacent_vertices_ids;
1074 
1081  element_iterator
1082  it = elements_begin(),
1083  endit = elements_end();
1084 
1085  for (; it != endit; ++it)
1086  {
1087  // the linear-order element
1088  Elem * lo_elem = *it;
1089 
1090  libmesh_assert(lo_elem);
1091 
1092  // make sure it is linear order
1093  if (lo_elem->default_order() != FIRST)
1094  libmesh_error_msg("ERROR: This is not a linear element: type=" << lo_elem->type());
1095 
1096  // this does _not_ work for refined elements
1097  libmesh_assert_equal_to (lo_elem->level (), 0);
1098 
1099  /*
1100  * build the second-order equivalent, add to
1101  * the new_elements list. Note that this here
1102  * is the only point where \p full_ordered
1103  * is necessary. The remaining code works well
1104  * for either type of second-order equivalent, e.g.
1105  * Hex20 or Hex27, as equivalents for Hex8
1106  */
1107  Elem * so_elem =
1109  full_ordered) ).release();
1110 
1111  libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());
1112 
1113 
1114  /*
1115  * By definition the vertices of the linear and
1116  * second order element are identically numbered.
1117  * transfer these.
1118  */
1119  for (unsigned int v=0; v < lo_elem->n_vertices(); v++)
1120  so_elem->set_node(v) = lo_elem->node_ptr(v);
1121 
1122  /*
1123  * Now handle the additional mid-side nodes. This
1124  * is simply handled through a map that remembers
1125  * the already-added nodes. This map maps the global
1126  * ids of the vertices (that uniquely define this
1127  * higher-order node) to the new node.
1128  * Notation: son = second-order node
1129  */
1130  const unsigned int son_begin = so_elem->n_vertices();
1131  const unsigned int son_end = so_elem->n_nodes();
1132 
1133 
1134  for (unsigned int son=son_begin; son<son_end; son++)
1135  {
1136  const unsigned int n_adjacent_vertices =
1137  so_elem->n_second_order_adjacent_vertices(son);
1138 
1139  adjacent_vertices_ids.resize(n_adjacent_vertices);
1140 
1141  for (unsigned int v=0; v<n_adjacent_vertices; v++)
1142  adjacent_vertices_ids[v] =
1143  so_elem->node_id( so_elem->second_order_adjacent_vertex(son,v) );
1144 
1145  /*
1146  * \p adjacent_vertices_ids is now in order of the current
1147  * side. sort it, so that comparisons with the
1148  * \p adjacent_vertices_ids created through other elements'
1149  * sides can match
1150  */
1151  std::sort(adjacent_vertices_ids.begin(),
1152  adjacent_vertices_ids.end());
1153 
1154 
1155  // does this set of vertices already have a mid-node added?
1156  auto pos = adj_vertices_to_so_nodes.equal_range (adjacent_vertices_ids);
1157 
1158  // no, not added yet
1159  if (pos.first == pos.second)
1160  {
1161  /*
1162  * for this set of vertices, there is no
1163  * second_order node yet. Add it.
1164  *
1165  * compute the location of the new node as
1166  * the average over the adjacent vertices.
1167  */
1168  Point new_location = this->point(adjacent_vertices_ids[0]);
1169  for (unsigned int v=1; v<n_adjacent_vertices; v++)
1170  new_location += this->point(adjacent_vertices_ids[v]);
1171 
1172  new_location /= static_cast<Real>(n_adjacent_vertices);
1173 
1174  /* Add the new point to the mesh.
1175  * If we are on a serialized mesh, then we're doing this
1176  * all in sync, and the node processor_id will be
1177  * consistent between processors.
1178  * If we are on a distributed mesh, we can fix
1179  * inconsistent processor ids later, but only if every
1180  * processor gives new nodes a *locally* consistent
1181  * processor id, so we'll give the new node the
1182  * processor id of an adjacent element for now and then
1183  * we'll update that later if appropriate.
1184  */
1185  Node * so_node = this->add_point
1186  (new_location, DofObject::invalid_id,
1187  lo_elem->processor_id());
1188 
1189  /*
1190  * insert the new node with its defining vertex
1191  * set into the map, and relocate pos to this
1192  * new entry, so that the so_elem can use
1193  * \p pos for inserting the node
1194  */
1195  adj_vertices_to_so_nodes.insert(pos.first,
1196  std::make_pair(adjacent_vertices_ids,
1197  so_node));
1198 
1199  so_elem->set_node(son) = so_node;
1200  }
1201  // yes, already added.
1202  else
1203  {
1204  Node * so_node = pos.first->second;
1205  libmesh_assert(so_node);
1206 
1207  so_elem->set_node(son) = so_node;
1208 
1209  // We need to ensure that the processor who should own a
1210  // node *knows* they own the node. And because
1211  // Node::choose_processor_id() may depend on Node id,
1212  // which may not yet be authoritative, we still have to
1213  // use a dumb-but-id-independent partitioning heuristic.
1214  processor_id_type chosen_pid =
1215  std::min (so_node->processor_id(),
1216  lo_elem->processor_id());
1217 
1218  // Plus, if we just discovered that we own this node,
1219  // then on a distributed mesh we need to make sure to
1220  // give it a valid id, not just a placeholder id!
1221  if (!this->is_replicated() &&
1222  so_node->processor_id() != this->processor_id() &&
1223  chosen_pid == this->processor_id())
1224  this->own_node(*so_node);
1225 
1226  so_node->processor_id() = chosen_pid;
1227  }
1228  }
1229 
1230  /*
1231  * find_neighbors relies on remote_elem neighbor links being
1232  * properly maintained.
1233  */
1234  for (auto s : lo_elem->side_index_range())
1235  {
1236  if (lo_elem->neighbor_ptr(s) == remote_elem)
1237  so_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
1238  }
1239 
1252  (this->get_boundary_info(), lo_elem, so_elem);
1253 
1254  /*
1255  * The new second-order element is ready.
1256  * Inserting it into the mesh will replace and delete
1257  * the first-order element.
1258  */
1259  so_elem->set_id(lo_elem->id());
1260 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1261  so_elem->set_unique_id() = lo_elem->unique_id();
1262 #endif
1263  so_elem->processor_id() = lo_elem->processor_id();
1264  so_elem->subdomain_id() = lo_elem->subdomain_id();
1265  this->insert_elem(so_elem);
1266  }
1267 
1268  // we can clear the map
1269  adj_vertices_to_so_nodes.clear();
1270 
1271 
1272  STOP_LOG("all_second_order()", "Mesh");
1273 
1274  // On a DistributedMesh our ghost node processor ids may be bad,
1275  // the ids of nodes touching remote elements may be inconsistent,
1276  // unique_ids of newly added non-local nodes remain unset, and our
1277  // partitioning of new nodes may not be well balanced.
1278  //
1279  // make_nodes_parallel_consistent() will fix all this.
1280  if (!this->is_serial())
1281  MeshCommunication().make_nodes_parallel_consistent (*this);
1282 
1283  // renumber nodes, elements etc
1284  this->prepare_for_use(/*skip_renumber =*/ false);
1285 }
virtual void reserve_nodes(const dof_id_type nn)=0
uint8_t processor_id_type
Definition: id_types.h:99
const Parallel::Communicator & comm() const
virtual void own_node(Node &)
Definition: mesh_base.h:639
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
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
virtual element_iterator elements_begin()=0
virtual bool is_serial() const
Definition: mesh_base.h:154
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:245
virtual element_iterator elements_end()=0
static const dof_id_type invalid_id
Definition: dof_object.h:347
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:152
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition: elem.C:2643
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)
virtual bool is_replicated() const
Definition: mesh_base.h:176
unsigned int mesh_dimension() const
Definition: mesh_base.C:126
virtual const Point & point(const dof_id_type i) const =0
virtual dof_id_type n_elem() const =0
processor_id_type processor_id() const
long double min(long double a, double b)
virtual dof_id_type n_nodes() const =0
virtual void renumber_nodes_and_elements()=0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ allgather()

void libMesh::DistributedMesh::allgather ( )
overridevirtualinherited

Gathers all elements and nodes of the mesh onto every processor

Reimplemented from libMesh::MeshBase.

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

1419 {
1420  if (_is_serial)
1421  return;
1422  MeshCommunication().allgather(*this);
1423  _is_serial = true;
1424  _is_serial_on_proc_0 = true;
1425 
1426  // Make sure our caches are up to date and our
1427  // DofObjects are well packed
1428 #ifdef DEBUG
1429  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1430  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1431  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1432  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1433  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1434  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1435 
1436  // If we've disabled renumbering we can't be sure we're contiguous
1437  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1438  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1439 
1440  // Make sure our neighbor links are all fine
1442 
1443  // Make sure our ids and flags are consistent
1446 #endif
1447 }
virtual dof_id_type parallel_n_nodes() const override
virtual void libmesh_assert_valid_parallel_ids() const override
virtual dof_id_type max_node_id() const override
void libmesh_assert_valid_parallel_flags() const
virtual dof_id_type parallel_n_elem() const override
virtual dof_id_type n_nodes() const override
dof_id_type parallel_max_node_id() const
virtual dof_id_type n_elem() const override
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
Definition: mesh_tools.C:2068
virtual dof_id_type max_elem_id() const override
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ allow_remote_element_removal() [1/2]

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

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

Definition at line 791 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

bool _allow_remote_element_removal
Definition: mesh_base.h:1439

◆ allow_remote_element_removal() [2/2]

bool libMesh::MeshBase::allow_remote_element_removal ( ) const
inlineinherited

◆ allow_renumbering() [1/2]

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

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

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

Definition at line 782 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

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

bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1431

◆ allow_renumbering() [2/2]

bool libMesh::MeshBase::allow_renumbering ( ) const
inlineinherited

◆ ancestor_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::ancestor_elements_begin ( )
overridevirtualinherited

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

Implements libMesh::MeshBase.

◆ ancestor_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ ancestor_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::ancestor_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ ancestor_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::ancestor_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ bid_nodes_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ bid_nodes_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ bid_nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ bid_nodes_end() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ bnd_nodes_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ bnd_nodes_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ bnd_nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::bnd_nodes_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ bnd_nodes_end() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::bnd_nodes_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )
inherited

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

Definition at line 574 of file mesh_base.C.

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

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

575 {
576  // This requires an inspection on every processor
577  parallel_object_only();
578 
579  // Need to clear _elem_dims first in case all elements of a
580  // particular dimension have been deleted.
581  _elem_dims.clear();
582 
583  for (const auto & elem : this->active_element_ptr_range())
584  _elem_dims.insert(cast_int<unsigned char>(elem->dim()));
585 
586  // Some different dimension elements may only live on other processors
587  this->comm().set_union(_elem_dims);
588 
589  // If the largest element dimension found is larger than the current
590  // _spatial_dimension, increase _spatial_dimension.
591  unsigned int max_dim = this->mesh_dimension();
592  if (max_dim > _spatial_dimension)
593  _spatial_dimension = cast_int<unsigned char>(max_dim);
594 
595  // _spatial_dimension may need to increase from 1->2 or 2->3 if the
596  // mesh is full of 1D elements but they are not x-aligned, or the
597  // mesh is full of 2D elements but they are not in the x-y plane.
598  // If the mesh is x-aligned or x-y planar, we will end up checking
599  // every node's coordinates and not breaking out of the loop
600  // early...
601  if (_spatial_dimension < 3)
602  {
603  for (const auto & node : this->node_ptr_range())
604  {
605 #if LIBMESH_DIM > 1
606  // Note: the exact floating point comparison is intentional,
607  // we don't want to get tripped up by tolerances.
608  if ((*node)(1) != 0.)
609  {
610  _spatial_dimension = 2;
611 #if LIBMESH_DIM == 2
612  // If libmesh is compiled in 2D mode, this is the
613  // largest spatial dimension possible so we can break
614  // out.
615  break;
616 #endif
617  }
618 #endif
619 
620 #if LIBMESH_DIM > 2
621  if ((*node)(2) != 0.)
622  {
623  // Spatial dimension can't get any higher than this, so
624  // we can break out.
625  _spatial_dimension = 3;
626  break;
627  }
628 #endif
629  }
630  }
631 }
void set_union(T &data, const unsigned int root_id) const
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
const Parallel::Communicator & comm() const
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
unsigned char _spatial_dimension
Definition: mesh_base.h:1459
virtual SimpleRange< node_iterator > node_ptr_range()=0
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1453
virtual const Node & node(const dof_id_type i) const
Definition: mesh_base.h:454
virtual unsigned short dim() const =0
unsigned int mesh_dimension() const
Definition: mesh_base.C:126

◆ clear()

void libMesh::DistributedMesh::clear ( )
overridevirtualinherited

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 764 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(), libMesh::MeshBase::elem(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node(), and libMesh::ParallelObject::processor_id().

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

765 {
766  // Call parent clear function
767  MeshBase::clear();
768 
769  // Clear our elements and nodes
770  // There is no need to remove the elements from
771  // the BoundaryInfo data structure since we
772  // already cleared it.
773  for (auto & elem : _elements)
774  delete elem;
775 
776  // clear the nodes data structure
777  // There is no need to remove the nodes from
778  // the BoundaryInfo data structure since we
779  // already cleared it.
780  for (auto & node : _nodes)
781  delete node;
782 
783  _elements.clear();
784  _nodes.clear();
785 
786  // We're no longer distributed if we were before
787  _is_serial = true;
788  _is_serial_on_proc_0 = true;
789 
790  // Correct our caches
791  _n_nodes = 0;
792  _n_elem = 0;
793  _max_node_id = 0;
794  _max_elem_id = 0;
799 }
mapvector< Elem *, dof_id_type > _elements
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
dof_id_type _next_free_local_node_id
processor_id_type n_processors() const
mapvector< Node *, dof_id_type > _nodes
virtual void clear()
Definition: mesh_base.C:260
dof_id_type _next_free_unpartitioned_node_id
virtual const Node & node(const dof_id_type i) const
Definition: mesh_base.h:454
dof_id_type _next_free_unpartitioned_elem_id
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id

◆ clear_extra_ghost_elems()

virtual void libMesh::DistributedMesh::clear_extra_ghost_elems ( )
inlinevirtualinherited

Clears extra ghost elements.

Definition at line 216 of file distributed_mesh.h.

References libMesh::DistributedMesh::_extra_ghost_elems.

216 { _extra_ghost_elems.clear(); }
std::set< Elem * > _extra_ghost_elems

◆ clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )
inherited

Releases the current PointLocator object.

Definition at line 517 of file mesh_base.C.

References libMesh::MeshBase::_point_locator.

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

518 {
519  _point_locator.reset(nullptr);
520 }
std::unique_ptr< PointLocatorBase > _point_locator
Definition: mesh_base.h:1398

◆ clone()

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

Virtual copy-constructor, creates a copy of this mesh

Reimplemented from libMesh::DistributedMesh.

Definition at line 44 of file parallel_mesh.h.

45  { return libmesh_make_unique<ParallelMesh>(*this); }

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

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

90  { return _communicator; }
const Parallel::Communicator & _communicator

◆ contract()

bool libMesh::UnstructuredMesh::contract ( )
overridevirtualinherited

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

Implements libMesh::MeshBase.

Definition at line 769 of file unstructured_mesh.C.

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

770 {
771  LOG_SCOPE ("contract()", "Mesh");
772 
773  // Flag indicating if this call actually changes the mesh
774  bool mesh_changed = false;
775 
776 #ifdef DEBUG
777  for (const auto & elem : this->element_ptr_range())
778  libmesh_assert(elem->active() || elem->subactive() || elem->ancestor());
779 #endif
780 
781  // Loop over the elements.
782  for (auto & elem : this->element_ptr_range())
783  {
784  // Delete all the subactive ones
785  if (elem->subactive())
786  {
787  // No level-0 element should be subactive.
788  // Note that we CAN'T test elem->level(), as that
789  // touches elem->parent()->dim(), and elem->parent()
790  // might have already been deleted!
791  libmesh_assert(elem->parent());
792 
793  // Delete the element
794  // This just sets a pointer to nullptr, and doesn't
795  // invalidate any iterators
796  this->delete_elem(elem);
797 
798  // the mesh has certainly changed
799  mesh_changed = true;
800  }
801  else
802  {
803  // Compress all the active ones
804  if (elem->active())
805  elem->contract();
806  else
807  libmesh_assert (elem->ancestor());
808  }
809  }
810 
811  // Strip any newly-created nullptr voids out of the element array
813 
814  // FIXME: Need to understand why deleting subactive children
815  // invalidates the point locator. For now we will clear it explicitly
816  this->clear_point_locator();
817 
818  // Allow our GhostingFunctor objects to reinit if necessary.
819  for (auto & gf : as_range(this->ghosting_functors_begin(),
820  this->ghosting_functors_end()))
821  {
822  libmesh_assert(gf);
823  gf->mesh_reinit();
824  }
825 
826  return mesh_changed;
827 }
const Elem * parent() const
Definition: elem.h:2479
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
bool ancestor() const
Definition: elem.C:1427
virtual void delete_elem(Elem *e)=0
virtual SimpleRange< element_iterator > element_ptr_range()=0
void clear_point_locator()
Definition: mesh_base.C:517
SimpleRange< I > as_range(const std::pair< I, I > &p)
Definition: simple_range.h:57
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Definition: mesh_base.h:835
bool subactive() const
Definition: elem.h:2408
bool active() const
Definition: elem.h:2390
virtual void renumber_nodes_and_elements()=0
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
Definition: mesh_base.h:841

◆ copy_nodes_and_elements()

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

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

Definition at line 61 of file unstructured_mesh.C.

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

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

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

◆ create_pid_mesh()

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

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

Definition at line 655 of file unstructured_mesh.C.

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

657 {
658 
659  // Issue a warning if the number the number of processors
660  // currently available is less that that requested for
661  // partitioning. This is not necessarily an error since
662  // you may run on one processor and still partition the
663  // mesh into several partitions.
664 #ifdef DEBUG
665  if (this->n_processors() < pid)
666  {
667  libMesh::out << "WARNING: You are creating a "
668  << "mesh for a processor id (="
669  << pid
670  << ") greater than "
671  << "the number of processors available for "
672  << "the calculation. (="
673  << this->n_processors()
674  << ")."
675  << std::endl;
676  }
677 #endif
678 
679  this->create_submesh (pid_mesh,
680  this->active_pid_elements_begin(pid),
681  this->active_pid_elements_end(pid));
682 }
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
OStreamProxy out(std::cout)
void create_submesh(UnstructuredMesh &new_mesh, const const_element_iterator &it, const const_element_iterator &it_end) const

◆ create_submesh()

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

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

Definition at line 690 of file unstructured_mesh.C.

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

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

693 {
694  // Just in case the subdomain_mesh already has some information
695  // in it, get rid of it.
696  new_mesh.clear();
697 
698  // If we're not serial, our submesh isn't either.
699  // There are no remote elements to delete on an empty mesh, but
700  // calling the method to do so marks the mesh as parallel.
701  if (!this->is_serial())
702  new_mesh.delete_remote_elements();
703 
704  // Fail if (*this == new_mesh), we cannot create a submesh inside ourself!
705  // This may happen if the user accidentally passes the original mesh into
706  // this function! We will check this by making sure we did not just
707  // clear ourself.
708  libmesh_assert_not_equal_to (this->n_nodes(), 0);
709  libmesh_assert_not_equal_to (this->n_elem(), 0);
710 
711  // Container to catch boundary IDs handed back by BoundaryInfo
712  std::vector<boundary_id_type> bc_ids;
713 
714  for (const auto & old_elem : as_range(it, it_end))
715  {
716  // Add an equivalent element type to the new_mesh.
717  // Copy ids for this element.
718  Elem * new_elem = Elem::build(old_elem->type()).release();
719  new_elem->set_id() = old_elem->id();
720 #ifdef LIBMESH_ENABLE_UNIQUE_ID
721  new_elem->set_unique_id() = old_elem->unique_id();
722 #endif
723  new_elem->subdomain_id() = old_elem->subdomain_id();
724  new_elem->processor_id() = old_elem->processor_id();
725 
726  new_mesh.add_elem (new_elem);
727 
728  libmesh_assert(new_elem);
729 
730  // Loop over the nodes on this element.
731  for (auto n : old_elem->node_index_range())
732  {
733  const dof_id_type this_node_id = old_elem->node_id(n);
734 
735  // Add this node to the new mesh if it's not there already
736  if (!new_mesh.query_node_ptr(this_node_id))
737  {
738 #ifdef LIBMESH_ENABLE_UNIQUE_ID
739  Node * newn =
740 #endif
741  new_mesh.add_point (old_elem->point(n),
742  this_node_id,
743  old_elem->node_ptr(n)->processor_id());
744 
745 #ifdef LIBMESH_ENABLE_UNIQUE_ID
746  newn->set_unique_id() = old_elem->node_ptr(n)->unique_id();
747 #endif
748  }
749 
750  // Define this element's connectivity on the new mesh
751  new_elem->set_node(n) = new_mesh.node_ptr(this_node_id);
752  }
753 
754  // Maybe add boundary conditions for this element
755  for (auto s : old_elem->side_index_range())
756  {
757  this->get_boundary_info().boundary_ids(old_elem, s, bc_ids);
758  new_mesh.get_boundary_info().add_side (new_elem, s, bc_ids);
759  }
760  } // end loop over elements
761 
762  // Prepare the new_mesh for use
763  new_mesh.prepare_for_use(/*skip_renumber =*/false);
764 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
std::vector< boundary_id_type > boundary_ids(const Node *node) const
virtual bool is_serial() const
Definition: mesh_base.h:154
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:245
SimpleRange< I > as_range(const std::pair< I, I > &p)
Definition: simple_range.h:57
virtual dof_id_type n_elem() const =0
virtual dof_id_type n_nodes() const =0
uint8_t dof_id_type
Definition: id_types.h:64

◆ default_ghosting()

GhostingFunctor& libMesh::MeshBase::default_ghosting ( )
inlineinherited

Default ghosting functor

Definition at line 847 of file mesh_base.h.

References libMesh::MeshBase::_default_ghosting.

847 { return *_default_ghosting; }
std::unique_ptr< GhostingFunctor > _default_ghosting
Definition: mesh_base.h:1466

◆ delete_elem()

void libMesh::DistributedMesh::delete_elem ( Elem e)
overridevirtualinherited

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 515 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::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::BoundaryInfo::remove().

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

516 {
517  libmesh_assert (e);
518 
519  // Try to make the cached elem data more accurate
520  processor_id_type elem_procid = e->processor_id();
521  if (elem_procid == this->processor_id() ||
522  elem_procid == DofObject::invalid_processor_id)
523  _n_elem--;
524 
525  // Delete the element from the BoundaryInfo object
526  this->get_boundary_info().remove(e);
527 
528  // But not yet from the container; we might invalidate
529  // an iterator that way!
530 
531  //_elements.erase(e->id());
532 
533  // Instead, we set it to nullptr for now
534 
535  _elements[e->id()] = nullptr;
536 
537  // delete the element
538  delete e;
539 }
mapvector< Elem *, dof_id_type > _elements
void remove(const Node *node)
uint8_t processor_id_type
Definition: id_types.h:99
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
processor_id_type processor_id() const

◆ delete_node()

void libMesh::DistributedMesh::delete_node ( Node n)
overridevirtualinherited

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 700 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::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::BoundaryInfo::remove().

701 {
702  libmesh_assert(n);
703  libmesh_assert(_nodes[n->id()]);
704 
705  // Try to make the cached elem data more accurate
706  processor_id_type node_procid = n->processor_id();
707  if (node_procid == this->processor_id() ||
708  node_procid == DofObject::invalid_processor_id)
709  _n_nodes--;
710 
711  // Delete the node from the BoundaryInfo object
712  this->get_boundary_info().remove(n);
713 
714  // But not yet from the container; we might invalidate
715  // an iterator that way!
716 
717  //_nodes.erase(n->id());
718 
719  // Instead, we set it to nullptr for now
720 
721  _nodes[n->id()] = nullptr;
722 
723  // delete the node
724  delete n;
725 }
void remove(const Node *node)
uint8_t processor_id_type
Definition: id_types.h:99
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
mapvector< Node *, dof_id_type > _nodes
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
processor_id_type processor_id() const

◆ delete_remote_elements()

void libMesh::DistributedMesh::delete_remote_elements ( )
overridevirtualinherited

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

1339 {
1340 #ifdef DEBUG
1341  // Make sure our neighbor links are all fine
1343 
1344  // And our child/parent links, and our flags
1346 
1347  // Make sure our ids and flags are consistent
1350 
1351  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1352  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1353  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1354  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1355  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1356  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1357 #endif
1358 
1359  _is_serial = false;
1360  _is_serial_on_proc_0 = false;
1361 
1362  MeshCommunication().delete_remote_elements(*this, _extra_ghost_elems);
1363 
1364  libmesh_assert_equal_to (this->max_elem_id(), this->parallel_max_elem_id());
1365 
1366  // Now make sure the containers actually shrink - strip
1367  // any newly-created nullptr voids out of the element array
1368  mapvector<Elem *,dof_id_type>::veclike_iterator e_it = _elements.begin();
1369  const mapvector<Elem *,dof_id_type>::veclike_iterator e_end = _elements.end();
1370  while (e_it != e_end)
1371  if (!*e_it)
1372  e_it = _elements.erase(e_it);
1373  else
1374  ++e_it;
1375 
1376  mapvector<Node *,dof_id_type>::veclike_iterator n_it = _nodes.begin();
1377  const mapvector<Node *,dof_id_type>::veclike_iterator n_end = _nodes.end();
1378  while (n_it != n_end)
1379  if (!*n_it)
1380  n_it = _nodes.erase(n_it);
1381  else
1382  ++n_it;
1383 
1384  // We may have deleted no-longer-connected nodes or coarsened-away
1385  // elements; let's update our caches.
1386  this->update_parallel_id_counts();
1387 
1388 #ifdef DEBUG
1389  // We might not have well-packed objects if the user didn't allow us
1390  // to renumber
1391  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1392  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1393 
1394  // Make sure our neighbor links are all fine
1396 
1397  // And our child/parent links, and our flags
1399 
1400  // Make sure our ids and flags are consistent
1403 #endif
1404 }
virtual void update_parallel_id_counts() override
virtual dof_id_type parallel_n_nodes() const override
mapvector< Elem *, dof_id_type > _elements
virtual void libmesh_assert_valid_parallel_ids() const override
virtual dof_id_type max_node_id() const override
void libmesh_assert_valid_refinement_tree(const MeshBase &mesh)
Definition: mesh_tools.C:2033
void libmesh_assert_valid_parallel_flags() const
virtual dof_id_type parallel_n_elem() const override
mapvector< Node *, dof_id_type > _nodes
std::set< Elem * > _extra_ghost_elems
virtual dof_id_type n_nodes() const override
dof_id_type parallel_max_node_id() const
virtual dof_id_type n_elem() const override
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
Definition: mesh_tools.C:2068
virtual dof_id_type max_elem_id() const override
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )
inherited

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

Definition at line 633 of file mesh_base.C.

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

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

634 {
635  // This requires an inspection on every processor
636  parallel_object_only();
637 
638  // Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
639  if (this->elem_dimensions().size() == 1)
640  return;
641 
642  //This map will be used to set interior parents
643  std::unordered_map<dof_id_type, std::vector<dof_id_type>> node_to_elem;
644 
645  for (const auto & elem : this->active_element_ptr_range())
646  {
647  // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
648  for (unsigned int n=0; n<elem->n_vertices(); n++)
649  {
650  libmesh_assert_less (elem->id(), this->max_elem_id());
651 
652  node_to_elem[elem->node_id(n)].push_back(elem->id());
653  }
654  }
655 
656  // Automatically set interior parents
657  for (const auto & element : this->element_ptr_range())
658  {
659  // Ignore an 3D element or an element that already has an interior parent
660  if (element->dim()>=LIBMESH_DIM || element->interior_parent())
661  continue;
662 
663  // Start by generating a SET of elements that are dim+1 to the current
664  // element at each vertex of the current element, thus ignoring interior nodes.
665  // If one of the SET of elements is empty, then we will not have an interior parent
666  // since an interior parent must be connected to all vertices of the current element
667  std::vector<std::set<dof_id_type>> neighbors( element->n_vertices() );
668 
669  bool found_interior_parents = false;
670 
671  for (dof_id_type n=0; n < element->n_vertices(); n++)
672  {
673  std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
674  for (const auto & eid : element_ids)
675  if (this->elem_ref(eid).dim() == element->dim()+1)
676  neighbors[n].insert(eid);
677 
678  if (neighbors[n].size()>0)
679  {
680  found_interior_parents = true;
681  }
682  else
683  {
684  // We have found an empty set, no reason to continue
685  // Ensure we set this flag to false before the break since it could have
686  // been set to true for previous vertex
687  found_interior_parents = false;
688  break;
689  }
690  }
691 
692  // If we have successfully generated a set of elements for each vertex, we will compare
693  // the set for vertex 0 will the sets for the vertices until we find a id that exists in
694  // all sets. If found, this is our an interior parent id. The interior parent id found
695  // will be the lowest element id if there is potential for multiple interior parents.
696  if (found_interior_parents)
697  {
698  std::set<dof_id_type> & neighbors_0 = neighbors[0];
699  for (const auto & interior_parent_id : neighbors_0)
700  {
701  found_interior_parents = false;
702  for (dof_id_type n=1; n < element->n_vertices(); n++)
703  {
704  if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
705  {
706  found_interior_parents=true;
707  }
708  else
709  {
710  found_interior_parents=false;
711  break;
712  }
713  }
714  if (found_interior_parents)
715  {
716  element->set_interior_parent(this->elem_ptr(interior_parent_id));
717  break;
718  }
719  }
720  }
721  }
722 }
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
virtual SimpleRange< element_iterator > element_ptr_range()=0
dof_id_type id() const
Definition: dof_object.h:655
virtual dof_id_type max_elem_id() const =0
const std::set< unsigned char > & elem_dimensions() const
Definition: mesh_base.h:220
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual unsigned int n_vertices() const =0
virtual unsigned short dim() const =0
virtual const Elem & elem_ref(const dof_id_type i) const
Definition: mesh_base.h:504
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:1914
uint8_t dof_id_type
Definition: id_types.h:64

◆ elem() [1/2]

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 537 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

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

538  {
539  libmesh_deprecated();
540  return this->elem_ptr(i);
541  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0

◆ elem() [2/2]

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 552 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

553  {
554  libmesh_deprecated();
555  return this->elem_ptr(i);
556  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0

◆ elem_dimensions()

const std::set<unsigned char>& libMesh::MeshBase::elem_dimensions ( ) const
inlineinherited
Returns
A const reference to a std::set of element dimensions present in the mesh.

Definition at line 220 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

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

221  { return _elem_dims; }
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1453

◆ elem_ptr() [1/2]

const Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i) const
overridevirtualinherited
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 331 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements.

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

332 {
333  libmesh_assert(_elements[i]);
334  libmesh_assert_equal_to (_elements[i]->id(), i);
335 
336  return _elements[i];
337 }
mapvector< Elem *, dof_id_type > _elements

◆ elem_ptr() [2/2]

Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i)
overridevirtualinherited
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 342 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements.

343 {
344  libmesh_assert(_elements[i]);
345  libmesh_assert_equal_to (_elements[i]->id(), i);
346 
347  return _elements[i];
348 }
mapvector< Elem *, dof_id_type > _elements

◆ elem_ref() [1/2]

◆ elem_ref() [2/2]

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 513 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

513  {
514  return *this->elem_ptr(i);
515  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0

◆ element_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::element_ptr_range ( )
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 298 of file distributed_mesh.h.

References libMesh::DistributedMesh::elements_begin(), and libMesh::DistributedMesh::elements_end().

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

298 { return {elements_begin(), elements_end()}; }
virtual element_iterator elements_end() override
virtual element_iterator elements_begin() override

◆ element_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::element_ptr_range ( ) const
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 299 of file distributed_mesh.h.

References libMesh::DistributedMesh::elements_begin(), and libMesh::DistributedMesh::elements_end().

299 { return {elements_begin(), elements_end()}; }
virtual element_iterator elements_end() override
virtual element_iterator elements_begin() override

◆ elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::elements_begin ( )
overridevirtualinherited

Elem iterator accessor functions.

Implements libMesh::MeshBase.

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

◆ elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::elements_end ( )
overridevirtualinherited

◆ elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ evaluable_elements_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ evaluable_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ evaluable_elements_end() [1/2]

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

Implements libMesh::MeshBase.

◆ evaluable_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ evaluable_nodes_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ evaluable_nodes_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ evaluable_nodes_end() [1/2]

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

Implements libMesh::MeshBase.

◆ evaluable_nodes_end() [2/2]

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

Implements libMesh::MeshBase.

◆ facelocal_elements_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ facelocal_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ facelocal_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::facelocal_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ facelocal_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::facelocal_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ find_neighbors()

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

Other functions from MeshBase requiring re-definition.

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

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

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

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

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

Implements libMesh::MeshBase.

Definition at line 240 of file unstructured_mesh.C.

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

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

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

◆ fix_broken_node_and_element_numbering()

void libMesh::DistributedMesh::fix_broken_node_and_element_numbering ( )
overridevirtualinherited

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

References libMesh::DistributedMesh::_elements, and libMesh::DistributedMesh::_nodes.

1298 {
1299  // We need access to iterators for the underlying containers,
1300  // not the mapvector<> reimplementations.
1303 
1304  // Nodes first
1305  for (auto & pr : nodes)
1306  if (pr.second != nullptr)
1307  pr.second->set_id() = pr.first;
1308 
1309  // Elements next
1310  for (const auto & pr : elems)
1311  if (pr.second != nullptr)
1312  pr.second->set_id() = pr.first;
1313 }
std::map< index_t, Val > maptype
Definition: mapvector.h:42
mapvector< Elem *, dof_id_type > _elements
mapvector< Node *, dof_id_type > _nodes

◆ flagged_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::flagged_elements_begin ( unsigned char  rflag)
overridevirtualinherited

Iterate over all elements with a specified refinement flag.

Implements libMesh::MeshBase.

◆ flagged_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ flagged_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::flagged_elements_end ( unsigned char  rflag)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ flagged_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ flagged_pid_elements_begin() [1/2]

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

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

Implements libMesh::MeshBase.

◆ flagged_pid_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ flagged_pid_elements_end() [1/2]

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

Implements libMesh::MeshBase.

◆ flagged_pid_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ gather_to_zero()

void libMesh::DistributedMesh::gather_to_zero ( )
overridevirtualinherited

Gathers all elements and nodes of the mesh onto processor zero

Reimplemented from libMesh::MeshBase.

Definition at line 1449 of file distributed_mesh.C.

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

1450 {
1452  return;
1453 
1454  _is_serial_on_proc_0 = true;
1455  MeshCommunication().gather(0, *this);
1456 }

◆ get_boundary_info() [1/2]

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

The information about boundary ids on the mesh

Definition at line 131 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

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

131 { return *boundary_info; }
std::unique_ptr< BoundaryInfo > boundary_info
Definition: mesh_base.h:1363

◆ get_boundary_info() [2/2]

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

Writable information about boundary ids on the mesh

Definition at line 136 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

136 { return *boundary_info; }
std::unique_ptr< BoundaryInfo > boundary_info
Definition: mesh_base.h:1363

◆ get_count_lower_dim_elems_in_point_locator()

bool libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator ( ) const
inherited

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 531 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

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

532 {
534 }
bool _count_lower_dim_elems_in_point_locator
Definition: mesh_base.h:1404

◆ get_id_by_name()

subdomain_id_type libMesh::MeshBase::get_id_by_name ( const std::string &  name) const
inherited
Returns
The id of the named subdomain if it exists, Elem::invalid_subdomain_id otherwise.

Definition at line 558 of file mesh_base.C.

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

559 {
560  // Linear search over the map values.
561  std::map<subdomain_id_type, std::string>::const_iterator
562  iter = _block_id_to_name.begin(),
563  end_iter = _block_id_to_name.end();
564 
565  for ( ; iter != end_iter; ++iter)
566  if (iter->second == name)
567  return iter->first;
568 
569  // If we made it here without returning, we don't have a subdomain
570  // with the requested name, so return Elem::invalid_subdomain_id.
572 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
static const subdomain_id_type invalid_subdomain_id
Definition: elem.h:262
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1446

◆ get_info()

std::string libMesh::MeshBase::get_info ( ) const
inherited
Returns
A string containing relevant information about the mesh.

Definition at line 378 of file mesh_base.C.

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

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

379 {
380  std::ostringstream oss;
381 
382  oss << " Mesh Information:" << '\n';
383 
384  if (!_elem_dims.empty())
385  {
386  oss << " elem_dimensions()={";
387  std::copy(_elem_dims.begin(),
388  --_elem_dims.end(), // --end() is valid if the set is non-empty
389  std::ostream_iterator<unsigned int>(oss, ", "));
390  oss << cast_int<unsigned int>(*_elem_dims.rbegin());
391  oss << "}\n";
392  }
393 
394  oss << " spatial_dimension()=" << this->spatial_dimension() << '\n'
395  << " n_nodes()=" << this->n_nodes() << '\n'
396  << " n_local_nodes()=" << this->n_local_nodes() << '\n'
397  << " n_elem()=" << this->n_elem() << '\n'
398  << " n_local_elem()=" << this->n_local_elem() << '\n'
399 #ifdef LIBMESH_ENABLE_AMR
400  << " n_active_elem()=" << this->n_active_elem() << '\n'
401 #endif
402  << " n_subdomains()=" << static_cast<std::size_t>(this->n_subdomains()) << '\n'
403  << " n_partitions()=" << static_cast<std::size_t>(this->n_partitions()) << '\n'
404  << " n_processors()=" << static_cast<std::size_t>(this->n_processors()) << '\n'
405  << " n_threads()=" << static_cast<std::size_t>(libMesh::n_threads()) << '\n'
406  << " processor_id()=" << static_cast<std::size_t>(this->processor_id()) << '\n';
407 
408  return oss.str();
409 }
virtual dof_id_type n_active_elem() const =0
unsigned int n_threads()
Definition: libmesh_base.h:96
dof_id_type n_local_nodes() const
Definition: mesh_base.h:286
dof_id_type n_local_elem() const
Definition: mesh_base.h:386
processor_id_type n_processors() const
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1453
unsigned int n_partitions() const
Definition: mesh_base.h:875
subdomain_id_type n_subdomains() const
Definition: mesh_base.C:304
unsigned int spatial_dimension() const
Definition: mesh_base.C:135
virtual dof_id_type n_elem() const =0
processor_id_type processor_id() const
virtual dof_id_type n_nodes() const =0

◆ get_subdomain_name_map()

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

Definition at line 1337 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

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

1338  { return _block_id_to_name; }
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1446

◆ ghost_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::ghost_elements_begin ( )
overridevirtualinherited

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

Implements libMesh::MeshBase.

◆ ghost_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ ghost_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::ghost_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ ghost_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::ghost_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ ghosting_functors_begin()

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

Beginning of range of ghosting functors

Definition at line 835 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

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

836  { return _ghosting_functors.begin(); }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1475

◆ ghosting_functors_end()

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

End of range of ghosting functors

Definition at line 841 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

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

842  { return _ghosting_functors.end(); }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1475

◆ insert_elem()

Elem * libMesh::DistributedMesh::insert_elem ( Elem e)
overridevirtualinherited

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

482 {
483  if (_elements[e->id()])
484  this->delete_elem(_elements[e->id()]);
485 
486 #ifdef LIBMESH_ENABLE_UNIQUE_ID
487  if (!e->valid_unique_id())
488  {
489  if (processor_id() == e->processor_id())
490  {
491  e->set_unique_id() = _next_unique_id;
492  _next_unique_id += this->n_processors() + 1;
493  }
494  else
495  {
496  e->set_unique_id() = _next_unpartitioned_unique_id;
498  }
499  }
500 #endif
501 
502  // Try to make the cached elem data more accurate
503  processor_id_type elem_procid = e->processor_id();
504  if (elem_procid == this->processor_id() ||
505  elem_procid == DofObject::invalid_processor_id)
506  _n_elem++;
507 
508  _elements[e->id()] = e;
509 
510  return e;
511 }
mapvector< Elem *, dof_id_type > _elements
uint8_t processor_id_type
Definition: id_types.h:99
unique_id_type _next_unique_id
Definition: mesh_base.h:1418
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
unique_id_type _next_unpartitioned_unique_id
processor_id_type processor_id() const
virtual void delete_elem(Elem *e) override

◆ insert_node()

Node * libMesh::DistributedMesh::insert_node ( Node n)
overridevirtualinherited

Calls add_node().

Implements libMesh::MeshBase.

Definition at line 693 of file distributed_mesh.C.

References libMesh::DistributedMesh::add_node().

694 {
695  return DistributedMesh::add_node(n);
696 }
virtual Node * add_node(Node *n) override

◆ is_prepared()

bool libMesh::MeshBase::is_prepared ( ) const
inlineinherited
Returns
true if the mesh has been prepared via a call to prepare_for_use, false otherwise.

Definition at line 147 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

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

148  { return _is_prepared; }

◆ is_replicated()

virtual bool libMesh::DistributedMesh::is_replicated ( ) const
inlineoverridevirtualinherited
Returns
true if new elements and nodes can and should be created in synchronization on all processors, false otherwise

Reimplemented from libMesh::MeshBase.

Definition at line 141 of file distributed_mesh.h.

142  { return false; }

◆ is_serial()

virtual bool libMesh::DistributedMesh::is_serial ( ) const
inlineoverridevirtualinherited
Returns
true if all elements and nodes of the mesh exist on the current processor, false otherwise

Reimplemented from libMesh::MeshBase.

Definition at line 119 of file distributed_mesh.h.

References libMesh::DistributedMesh::_is_serial.

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

120  { return _is_serial; }

◆ is_serial_on_zero()

virtual bool libMesh::DistributedMesh::is_serial_on_zero ( ) const
inlineoverridevirtualinherited
Returns
true if all elements and nodes of the mesh exist on the processor 0, false otherwise

Reimplemented from libMesh::MeshBase.

Definition at line 126 of file distributed_mesh.h.

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

◆ level_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::level_elements_begin ( unsigned int  level)
overridevirtualinherited

Iterate over elements of a given level.

Implements libMesh::MeshBase.

◆ level_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ level_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::level_elements_end ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ level_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ libmesh_assert_valid_parallel_flags()

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

References libMesh::DistributedMesh::_elements, libMesh::Elem::active(), libMesh::ParallelObject::comm(), libMesh::invalid_uint, 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(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

932 {
933 #if defined(LIBMESH_ENABLE_AMR) && !defined(NDEBUG)
934  // This function must be run on all processors at once
935  parallel_object_only();
936 
937  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
938 
939  for (dof_id_type i=0; i != pmax_elem_id; ++i)
940  {
941  Elem * el = _elements[i]; // Returns nullptr if there's no map entry
942 
943  unsigned int refinement_flag = el ?
944  static_cast<unsigned int> (el->refinement_flag()) : libMesh::invalid_uint;
945  unsigned int p_refinement_flag = el ?
946  static_cast<unsigned int> (el->p_refinement_flag()) : libMesh::invalid_uint;
947 
948  libmesh_assert(this->comm().semiverify(el ? &refinement_flag : nullptr));
949 
950  // p refinement flags aren't always kept correct on inactive
951  // ghost elements
952  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_refinement_flag : nullptr));
953  }
954 #endif // LIBMESH_ENABLE_AMR
955 }
mapvector< Elem *, dof_id_type > _elements
const unsigned int invalid_uint
Definition: libmesh.h:245
const Parallel::Communicator & comm() const
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ libmesh_assert_valid_parallel_ids()

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids ( ) const
overridevirtualinherited

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 900 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(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

901 {
904 }
mapvector< Elem *, dof_id_type > _elements
void libmesh_assert_valid_parallel_object_ids(const mapvector< T *, dof_id_type > &) const
mapvector< Node *, dof_id_type > _nodes

◆ libmesh_assert_valid_parallel_object_ids()

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

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, 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::libmesh_assert_valid_parallel_ids().

845 {
846  // This function must be run on all processors at once
847  parallel_object_only();
848 
849  const dof_id_type pmax_node_id = this->parallel_max_node_id();
850  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
851  const dof_id_type pmax_id = std::max(pmax_node_id, pmax_elem_id);
852 
853  for (dof_id_type i=0; i != pmax_id; ++i)
854  {
855  T * obj = objects[i]; // Returns nullptr if there's no map entry
856 
857  // Local lookups by id should return the requested object
858  libmesh_assert(!obj || obj->id() == i);
859 
860  // All processors with an object should agree on id
861 #ifndef NDEBUG
862  const dof_id_type dofid = obj && obj->valid_id() ?
863  obj->id() : DofObject::invalid_id;
864  libmesh_assert(this->comm().semiverify(obj ? &dofid : nullptr));
865 #endif
866 
867  // All processors with an object should agree on processor id
868  const dof_id_type procid = obj && obj->valid_processor_id() ?
869  obj->processor_id() : DofObject::invalid_processor_id;
870  libmesh_assert(this->comm().semiverify(obj ? &procid : nullptr));
871 
872  dof_id_type min_procid = procid;
873  this->comm().min(min_procid);
874 
875  // Either:
876  // 1.) I own this elem (min_procid == this->processor_id()) *and* I have a valid pointer to it (obj != nullptr)
877  // or
878  // 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.)
879 
880  // Original assert logic
881  // libmesh_assert (min_procid != this->processor_id() || obj);
882 
883  // More human-understandable logic...
884  libmesh_assert (
885  ((min_procid == this->processor_id()) && obj)
886  ||
887  (min_procid != this->processor_id())
888  );
889 
890 #if defined(LIBMESH_ENABLE_UNIQUE_ID) && !defined(NDEBUG)
891  // All processors with an object should agree on unique id
892  const unique_id_type uniqueid = obj ? obj->unique_id() : 0;
893  libmesh_assert(this->comm().semiverify(obj ? &uniqueid : nullptr));
894 #endif
895  }
896 }
const Parallel::Communicator & comm() const
long double max(long double a, double b)
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
static const dof_id_type invalid_id
Definition: dof_object.h:347
dof_id_type parallel_max_node_id() const
processor_id_type processor_id() const
uint8_t unique_id_type
Definition: id_types.h:79
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ libmesh_assert_valid_parallel_p_levels()

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

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

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

909 {
910 #ifndef NDEBUG
911  // This function must be run on all processors at once
912  parallel_object_only();
913 
914  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
915 
916  for (dof_id_type i=0; i != pmax_elem_id; ++i)
917  {
918  Elem * el = _elements[i]; // Returns nullptr if there's no map entry
919 
920  unsigned int p_level = el ? (el->p_level()) : libMesh::invalid_uint;
921 
922  // All processors with an active element should agree on p level
923  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_level : nullptr));
924  }
925 #endif
926 }
mapvector< Elem *, dof_id_type > _elements
const unsigned int invalid_uint
Definition: libmesh.h:245
const Parallel::Communicator & comm() const
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ local_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::local_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::local_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_level_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_level_elements_begin ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_level_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ local_level_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_level_elements_end ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_level_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ local_node_ptr_range() [1/2]

virtual SimpleRange<node_iterator> libMesh::DistributedMesh::local_node_ptr_range ( )
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 491 of file distributed_mesh.h.

References libMesh::DistributedMesh::local_nodes_begin(), and libMesh::DistributedMesh::local_nodes_end().

491 { return {local_nodes_begin(), local_nodes_end()}; }
virtual node_iterator local_nodes_end() override
virtual node_iterator local_nodes_begin() override

◆ local_node_ptr_range() [2/2]

virtual SimpleRange<const_node_iterator> libMesh::DistributedMesh::local_node_ptr_range ( ) const
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 492 of file distributed_mesh.h.

References libMesh::DistributedMesh::local_nodes_begin(), and libMesh::DistributedMesh::local_nodes_end().

492 { return {local_nodes_begin(), local_nodes_end()}; }
virtual node_iterator local_nodes_end() override
virtual node_iterator local_nodes_begin() override

◆ local_nodes_begin() [1/2]

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

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

Implements libMesh::MeshBase.

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

◆ local_nodes_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ local_nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::local_nodes_end ( )
overridevirtualinherited

◆ local_nodes_end() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::local_nodes_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_not_level_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_begin ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_not_level_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ local_not_level_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_end ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ local_not_level_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ max_elem_id()

virtual dof_id_type libMesh::DistributedMesh::max_elem_id ( ) const
inlineoverridevirtualinherited

◆ max_node_id()

virtual dof_id_type libMesh::DistributedMesh::max_node_id ( ) const
inlineoverridevirtualinherited

◆ mesh_dimension()

unsigned int libMesh::MeshBase::mesh_dimension ( ) const
inherited
Returns
The logical dimension of the mesh; i.e. the manifold dimension of the elements in the mesh. If we ever support multi-dimensional meshes (e.g. hexes and quads in the same mesh) then this will return the largest such dimension.

Definition at line 126 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

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

127 {
128  if (!_elem_dims.empty())
129  return cast_int<unsigned int>(*_elem_dims.rbegin());
130  return 0;
131 }
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1453

◆ n_active_elem()

dof_id_type libMesh::DistributedMesh::n_active_elem ( ) const
overridevirtualinherited
Returns
The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

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

1318 {
1319  parallel_object_only();
1320 
1321  // Get local active elements first
1322  dof_id_type active_elements =
1323  static_cast<dof_id_type>(std::distance (this->active_local_elements_begin(),
1324  this->active_local_elements_end()));
1325  this->comm().sum(active_elements);
1326 
1327  // Then add unpartitioned active elements, which should exist on
1328  // every processor
1329  active_elements +=
1330  static_cast<dof_id_type>(std::distance
1333  return active_elements;
1334 }
virtual element_iterator active_local_elements_end() override
virtual element_iterator active_pid_elements_begin(processor_id_type proc_id) override
const Parallel::Communicator & comm() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
virtual element_iterator active_pid_elements_end(processor_id_type proc_id) override
virtual element_iterator active_local_elements_begin() override
uint8_t dof_id_type
Definition: id_types.h:64

◆ n_active_elem_on_proc()

dof_id_type libMesh::MeshBase::n_active_elem_on_proc ( const processor_id_type  proc) const
inherited
Returns
The number of active elements on processor proc.

Definition at line 345 of file mesh_base.C.

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

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

346 {
347  libmesh_assert_less (proc_id, this->n_processors());
348  return static_cast<dof_id_type>(std::distance (this->active_pid_elements_begin(proc_id),
349  this->active_pid_elements_end (proc_id)));
350 }
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

◆ n_active_local_elem()

dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const
inlineinherited
Returns
The number of active elements on the local processor.

Definition at line 403 of file mesh_base.h.

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

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

404  { return this->n_active_elem_on_proc (this->processor_id()); }
dof_id_type n_active_elem_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:345
processor_id_type processor_id() const

◆ n_active_sub_elem()

dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const
inherited

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

Definition at line 366 of file mesh_base.C.

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

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

367 {
368  dof_id_type ne=0;
369 
370  for (const auto & elem : this->active_element_ptr_range())
371  ne += elem->n_sub_elem();
372 
373  return ne;
374 }
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
virtual unsigned int n_sub_elem() const =0
uint8_t dof_id_type
Definition: id_types.h:64

◆ n_elem()

virtual dof_id_type libMesh::DistributedMesh::n_elem ( ) const
inlineoverridevirtualinherited
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 222 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_elem.

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

222 { return _n_elem; }

◆ n_elem_on_proc()

dof_id_type libMesh::MeshBase::n_elem_on_proc ( const processor_id_type  proc) const
inherited
Returns
The number of elements on processor proc.

Definition at line 332 of file mesh_base.C.

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

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

333 {
334  // We're either counting a processor's elements or unpartitioned
335  // elements
336  libmesh_assert (proc_id < this->n_processors() ||
338 
339  return static_cast<dof_id_type>(std::distance (this->pid_elements_begin(proc_id),
340  this->pid_elements_end (proc_id)));
341 }
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
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

◆ n_local_elem()

dof_id_type libMesh::MeshBase::n_local_elem ( ) const
inlineinherited
Returns
The number of elements on the local processor.

Definition at line 386 of file mesh_base.h.

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

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

387  { 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:332
processor_id_type processor_id() const

◆ n_local_nodes()

dof_id_type libMesh::MeshBase::n_local_nodes ( ) const
inlineinherited
Returns
The number of nodes on the local processor.

Definition at line 286 of file mesh_base.h.

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

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

287  { 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:319
processor_id_type processor_id() const

◆ n_nodes()

virtual dof_id_type libMesh::DistributedMesh::n_nodes ( ) const
inlineoverridevirtualinherited
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 219 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_nodes.

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

219 { return _n_nodes; }

◆ n_nodes_on_proc()

dof_id_type libMesh::MeshBase::n_nodes_on_proc ( const processor_id_type  proc) const
inherited
Returns
The number of nodes on processor proc.

Definition at line 319 of file mesh_base.C.

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

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

320 {
321  // We're either counting a processor's nodes or unpartitioned
322  // nodes
323  libmesh_assert (proc_id < this->n_processors() ||
325 
326  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
327  this->pid_nodes_end (proc_id)));
328 }
virtual node_iterator pid_nodes_end(processor_id_type proc_id)=0
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
virtual node_iterator pid_nodes_begin(processor_id_type proc_id)=0
uint8_t dof_id_type
Definition: id_types.h:64

◆ n_partitions()

unsigned int libMesh::MeshBase::n_partitions ( ) const
inlineinherited
Returns
The number of partitions which have been defined via a call to either mesh.partition() or by building a Partitioner object and calling partition.
Note
The partitioner object is responsible for setting this value.

Definition at line 875 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

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

876  { return _n_parts; }
unsigned int _n_parts
Definition: mesh_base.h:1384

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

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

96  { return cast_int<processor_id_type>(_communicator.size()); }
processor_id_type size() const
Definition: communicator.h:175
const Parallel::Communicator & _communicator

◆ n_sub_elem()

dof_id_type libMesh::MeshBase::n_sub_elem ( ) const
inherited
Returns
The number of elements that will be written out in certain I/O formats.

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

Definition at line 354 of file mesh_base.C.

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

355 {
356  dof_id_type ne=0;
357 
358  for (const auto & elem : this->element_ptr_range())
359  ne += elem->n_sub_elem();
360 
361  return ne;
362 }
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
virtual SimpleRange< element_iterator > element_ptr_range()=0
virtual unsigned int n_sub_elem() const =0
uint8_t dof_id_type
Definition: id_types.h:64

◆ n_subdomains()

subdomain_id_type libMesh::MeshBase::n_subdomains ( ) const
inherited
Returns
The number of subdomains in the global mesh. Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Definition at line 304 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

305 {
306  // This requires an inspection on every processor
307  parallel_object_only();
308 
309  std::set<subdomain_id_type> ids;
310 
311  this->subdomain_ids (ids);
312 
313  return cast_int<subdomain_id_type>(ids.size());
314 }
void subdomain_ids(std::set< subdomain_id_type > &ids) const
Definition: mesh_base.C:288

◆ n_unpartitioned_elem()

dof_id_type libMesh::MeshBase::n_unpartitioned_elem ( ) const
inlineinherited
Returns
The number of elements owned by no processor.

Definition at line 392 of file mesh_base.h.

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

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

dof_id_type n_elem_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:332
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358

◆ n_unpartitioned_nodes()

dof_id_type libMesh::MeshBase::n_unpartitioned_nodes ( ) const
inlineinherited
Returns
The number of nodes owned by no processor.

Definition at line 292 of file mesh_base.h.

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

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

static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
dof_id_type n_nodes_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:319

◆ next_unique_id()

unique_id_type libMesh::MeshBase::next_unique_id ( )
inlineinherited
Returns
The next unique id to be used.

Definition at line 305 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

305 { return _next_unique_id; }
unique_id_type _next_unique_id
Definition: mesh_base.h:1418

◆ node() [1/2]

virtual const Node& libMesh::MeshBase::node ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A constant reference (for reading only) to the $ 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 454 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

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

455  {
456  libmesh_deprecated();
457  return *this->node_ptr(i);
458  }
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ node() [2/2]

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 468 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

469  {
470  libmesh_deprecated();
471  return *this->node_ptr(i);
472  }
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ node_ptr() [1/2]

const Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i) const
overridevirtualinherited
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 277 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes.

278 {
279  libmesh_assert(_nodes[i]);
280  libmesh_assert_equal_to (_nodes[i]->id(), i);
281 
282  return _nodes[i];
283 }
mapvector< Node *, dof_id_type > _nodes

◆ node_ptr() [2/2]

Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i)
overridevirtualinherited
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 288 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes.

289 {
290  libmesh_assert(_nodes[i]);
291  libmesh_assert_equal_to (_nodes[i]->id(), i);
292 
293  return _nodes[i];
294 }
mapvector< Node *, dof_id_type > _nodes

◆ node_ptr_range() [1/2]

virtual SimpleRange<node_iterator> libMesh::DistributedMesh::node_ptr_range ( )
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 479 of file distributed_mesh.h.

References libMesh::DistributedMesh::nodes_begin(), and libMesh::DistributedMesh::nodes_end().

479 { return {nodes_begin(), nodes_end()}; }
virtual node_iterator nodes_begin() override
virtual node_iterator nodes_end() override

◆ node_ptr_range() [2/2]

virtual SimpleRange<const_node_iterator> libMesh::DistributedMesh::node_ptr_range ( ) const
inlineoverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 480 of file distributed_mesh.h.

References libMesh::DistributedMesh::nodes_begin(), and libMesh::DistributedMesh::nodes_end().

480 { return {nodes_begin(), nodes_end()}; }
virtual node_iterator nodes_begin() override
virtual node_iterator nodes_end() override

◆ node_ref() [1/2]

virtual const Node& libMesh::MeshBase::node_ref ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A constant reference (for reading only) to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.

Definition at line 434 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

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

434  {
435  return *this->node_ptr(i);
436  }
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ node_ref() [2/2]

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 442 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

442  {
443  return *this->node_ptr(i);
444  }
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ nodes_begin() [1/2]

virtual node_iterator libMesh::DistributedMesh::nodes_begin ( )
overridevirtualinherited

Node iterator accessor functions.

Implements libMesh::MeshBase.

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

◆ nodes_begin() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::nodes_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::nodes_end ( )
overridevirtualinherited

◆ nodes_end() [2/2]

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

Implements libMesh::MeshBase.

◆ not_active_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_active_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_active_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_active_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_active_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_active_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_ancestor_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_ancestor_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_ancestor_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_ancestor_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_level_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_level_elements_begin ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_level_elements_begin() [2/2]

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

Implements libMesh::MeshBase.

◆ not_level_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_level_elements_end ( unsigned int  level)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_level_elements_end() [2/2]

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

Implements libMesh::MeshBase.

◆ not_local_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_local_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_local_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_local_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_local_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_local_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_subactive_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_subactive_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_subactive_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ not_subactive_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ own_node()

void libMesh::DistributedMesh::own_node ( Node n)
overridevirtualinherited

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

Reimplemented from libMesh::MeshBase.

Definition at line 582 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, libMesh::DistributedMesh::add_node(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::DofObject::set_id().

583 {
584  // This had better be a node in our mesh
585  libmesh_assert(_nodes[n.id()] == &n);
586 
587  _nodes[n.id()] = nullptr;
588 
589  n.set_id(DofObject::invalid_id);
590  n.processor_id() = this->processor_id();
591 
592  this->add_node(&n);
593 }
mapvector< Node *, dof_id_type > _nodes
static const dof_id_type invalid_id
Definition: dof_object.h:347
virtual Node * add_node(Node *n) override
processor_id_type processor_id() const

◆ parallel_max_elem_id()

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

Definition at line 182 of file distributed_mesh.C.

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

Referenced by libMesh::DistributedMesh::allgather(), 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(), and libMesh::DistributedMesh::update_parallel_id_counts().

183 {
184  // This function must be run on all processors at once
185  parallel_object_only();
186 
187  dof_id_type max_local = 0;
188 
189  mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
190  rit = _elements.rbegin();
191 
192  const mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
193  rend = _elements.rend();
194 
195  // Look for the maximum element id. Search backwards through
196  // elements so we can break out early. Beware of nullptr entries that
197  // haven't yet been cleared from _elements.
198  for (; rit != rend; ++rit)
199  if (rit->second)
200  {
201  libmesh_assert_equal_to(rit->second->id(), rit->first);
202  max_local = rit->first + 1;
203  break;
204  }
205 
206  this->comm().max(max_local);
207  return max_local;
208 }
mapvector< Elem *, dof_id_type > _elements
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ parallel_max_node_id()

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

Definition at line 240 of file distributed_mesh.C.

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

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

241 {
242  // This function must be run on all processors at once
243  parallel_object_only();
244 
245  dof_id_type max_local = 0;
246 
247  mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
248  rit = _nodes.rbegin();
249 
250  const mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
251  rend = _nodes.rend();
252 
253  // Look for the maximum element id. Search backwards through
254  // elements so we can break out early. Beware of nullptr entries that
255  // haven't yet been cleared from _elements.
256  for (; rit != rend; ++rit)
257  if (rit->second)
258  {
259  libmesh_assert_equal_to(rit->second->id(), rit->first);
260  max_local = rit->first + 1;
261  break;
262  }
263 
264  this->comm().max(max_local);
265  return max_local;
266 }
const Parallel::Communicator & comm() const
mapvector< Node *, dof_id_type > _nodes
uint8_t dof_id_type
Definition: id_types.h:64

◆ parallel_max_unique_id()

unique_id_type libMesh::DistributedMesh::parallel_max_unique_id ( ) const
overridevirtualinherited
Returns
A number greater than or equal to the maximum unique_id in the mesh.

Implements libMesh::MeshBase.

Definition at line 213 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::update_parallel_id_counts().

214 {
215  // This function must be run on all processors at once
216  parallel_object_only();
217 
220  this->comm().max(max_local);
221  return max_local;
222 }
const Parallel::Communicator & comm() const
long double max(long double a, double b)
unique_id_type _next_unique_id
Definition: mesh_base.h:1418
unique_id_type _next_unpartitioned_unique_id
uint8_t unique_id_type
Definition: id_types.h:79

◆ parallel_n_elem()

dof_id_type libMesh::DistributedMesh::parallel_n_elem ( ) const
overridevirtualinherited
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 169 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(), and libMesh::DistributedMesh::update_parallel_id_counts().

170 {
171  // This function must be run on all processors at once
172  parallel_object_only();
173 
174  dof_id_type n_local = this->n_local_elem();
175  this->comm().sum(n_local);
176  n_local += this->n_unpartitioned_elem();
177  return n_local;
178 }
const Parallel::Communicator & comm() const
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:392
dof_id_type n_local_elem() const
Definition: mesh_base.h:386
uint8_t dof_id_type
Definition: id_types.h:64

◆ parallel_n_nodes()

dof_id_type libMesh::DistributedMesh::parallel_n_nodes ( ) const
overridevirtualinherited
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 227 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(), and libMesh::DistributedMesh::update_parallel_id_counts().

228 {
229  // This function must be run on all processors at once
230  parallel_object_only();
231 
232  dof_id_type n_local = this->n_local_nodes();
233  this->comm().sum(n_local);
234  n_local += this->n_unpartitioned_nodes();
235  return n_local;
236 }
dof_id_type n_unpartitioned_nodes() const
Definition: mesh_base.h:292
dof_id_type n_local_nodes() const
Definition: mesh_base.h:286
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:64

◆ partition() [1/2]

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

Call the default partitioner (currently metis_partition()).

Definition at line 426 of file mesh_base.C.

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

Referenced by libMesh::split_mesh().

427 {
428  // If we get here and we have unpartitioned elements, we need that
429  // fixed.
430  if (this->n_unpartitioned_elem() > 0)
431  {
432  libmesh_assert (partitioner().get());
433  libmesh_assert (this->is_serial());
434  partitioner()->partition (*this, n_parts);
435  }
436  // A nullptr partitioner means don't repartition; skip_partitioning()
437  // checks on this.
438  // Non-serial meshes may not be ready for repartitioning here.
439  else if (!skip_partitioning())
440  {
441  partitioner()->partition (*this, n_parts);
442  }
443  else
444  {
445  // Adaptive coarsening may have "orphaned" nodes on processors
446  // whose elements no longer share them. We need to check for
447  // and possibly fix that.
449 
450  // Make sure locally cached partition count is correct
451  this->recalculate_n_partitions();
452 
453  // Make sure any other locally cached data is correct
454  this->update_post_partitioning();
455  }
456 }
void correct_node_proc_ids(MeshBase &)
Definition: mesh_tools.C:2259
virtual std::unique_ptr< Partitioner > & partitioner()
Definition: mesh_base.h:126
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:392
virtual bool is_serial() const
Definition: mesh_base.h:154
bool skip_partitioning() const
Definition: mesh_base.h:812
unsigned int recalculate_n_partitions()
Definition: mesh_base.C:458
virtual void update_post_partitioning()
Definition: mesh_base.h:763

◆ partition() [2/2]

void libMesh::MeshBase::partition ( )
inlineinherited

Definition at line 749 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

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

750  { this->partition(this->n_processors()); }
processor_id_type n_processors() const

◆ partitioner()

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

A partitioner to use at each prepare_for_use()

Definition at line 126 of file mesh_base.h.

References libMesh::MeshBase::_partitioner.

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

126 { return _partitioner; }
std::unique_ptr< Partitioner > _partitioner
Definition: mesh_base.h:1412

◆ pid_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::pid_elements_begin ( processor_id_type  proc_id)
overridevirtualinherited

Iterate over all elements with a specified processor id.

Implements libMesh::MeshBase.

◆ pid_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::pid_elements_begin ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ pid_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::pid_elements_end ( processor_id_type  proc_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ pid_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::pid_elements_end ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ pid_nodes_begin() [1/2]

virtual node_iterator libMesh::DistributedMesh::pid_nodes_begin ( processor_id_type  proc_id)
overridevirtualinherited

Iterate over nodes with processor_id() == proc_id

Implements libMesh::MeshBase.

◆ pid_nodes_begin() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::pid_nodes_begin ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ pid_nodes_end() [1/2]

virtual node_iterator libMesh::DistributedMesh::pid_nodes_end ( processor_id_type  proc_id)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ pid_nodes_end() [2/2]

virtual const_node_iterator libMesh::DistributedMesh::pid_nodes_end ( processor_id_type  proc_id) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ point()

const Point & libMesh::DistributedMesh::point ( const dof_id_type  i) const
overridevirtualinherited
Returns
A constant reference (for reading only) to the $ i^{th} $ point, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 270 of file distributed_mesh.C.

References libMesh::MeshBase::node_ref().

271 {
272  return this->node_ref(i);
273 }
virtual const Node & node_ref(const dof_id_type i) const
Definition: mesh_base.h:434

◆ point_locator()

const PointLocatorBase & libMesh::MeshBase::point_locator ( ) const
inherited
Returns
A pointer to a PointLocatorBase object for this mesh, constructing a master PointLocator first if necessary.
Deprecated:
This should never be used in threaded or non-parallel_only code.

Definition at line 479 of file mesh_base.C.

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

480 {
481  libmesh_deprecated();
482 
483  if (_point_locator.get() == nullptr)
484  {
485  // PointLocator construction may not be safe within threads
486  libmesh_assert(!Threads::in_threads);
487 
489  }
490 
491  return *_point_locator;
492 }
bool in_threads
Definition: threads.C:31
std::unique_ptr< PointLocatorBase > _point_locator
Definition: mesh_base.h:1398
static std::unique_ptr< PointLocatorBase > build(PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)

◆ prepare_for_use()

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

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

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

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

Definition at line 152 of file mesh_base.C.

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

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

153 {
154  LOG_SCOPE("prepare_for_use()", "MeshBase");
155 
156  parallel_object_only();
157 
158  libmesh_assert(this->comm().verify(this->is_serial()));
159 
160  // A distributed mesh may have processors with no elements (or
161  // processors with no elements of higher dimension, if we ever
162  // support mixed-dimension meshes), but we want consistent
163  // mesh_dimension anyways.
164  //
165  // cache_elem_dims() should get the elem_dimensions() and
166  // mesh_dimension() correct later, and we don't need it earlier.
167 
168 
169  // Renumber the nodes and elements so that they in contiguous
170  // blocks. By default, _skip_renumber_nodes_and_elements is false.
171  //
172  // We may currently change that by passing
173  // skip_renumber_nodes_and_elements==true to this function, but we
174  // should use the allow_renumbering() accessor instead.
175  //
176  // Instances where you if prepare_for_use() should not renumber the nodes
177  // and elements include reading in e.g. an xda/r or gmv file. In
178  // this case, the ordering of the nodes may depend on an accompanying
179  // solution, and the node ordering cannot be changed.
180 
181  if (skip_renumber_nodes_and_elements)
182  {
183  libmesh_deprecated();
184  this->allow_renumbering(false);
185  }
186 
187  // Mesh modification operations might not leave us with consistent
188  // id counts, but our partitioner might need that consistency.
191  else
193 
194  // Let all the elements find their neighbors
195  if (!skip_find_neighbors)
196  this->find_neighbors();
197 
198  // The user may have set boundary conditions. We require that the
199  // boundary conditions were set consistently. Because we examine
200  // neighbors when evaluating non-raw boundary condition IDs, this
201  // assert is only valid when our neighbor links are in place.
202 #ifdef DEBUG
204 #endif
205 
206  // Search the mesh for all the dimensions of the elements
207  // and cache them.
208  this->cache_elem_dims();
209 
210  // Search the mesh for elements that have a neighboring element
211  // of dim+1 and set that element as the interior parent
212  this->detect_interior_parents();
213 
214  // Fix up node unique ids in case mesh generation code didn't take
215  // exceptional care to do so.
216  // MeshCommunication().make_node_unique_ids_parallel_consistent(*this);
217 
218  // We're going to still require that mesh generation code gets
219  // element unique ids consistent.
220 #if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
222 #endif
223 
224  // Reset our PointLocator. Any old locator is invalidated any time
225  // the elements in the underlying elements in the mesh have changed,
226  // so we clear it here.
227  this->clear_point_locator();
228 
229  // Allow our GhostingFunctor objects to reinit if necessary.
230  // Do this before partitioning and redistributing, and before
231  // deleting remote elements.
232  for (auto & gf : _ghosting_functors)
233  {
234  libmesh_assert(gf);
235  gf->mesh_reinit();
236  }
237 
238  // Partition the mesh.
239  this->partition();
240 
241  // If we're using DistributedMesh, we'll probably want it
242  // parallelized.
244  this->delete_remote_elements();
245 
248 
249  // The mesh is now prepared for use.
250  _is_prepared = true;
251 
252 #if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
255 #endif
256 }
bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1431
void detect_interior_parents()
Definition: mesh_base.C:633
const Parallel::Communicator & comm() const
bool _allow_remote_element_removal
Definition: mesh_base.h:1439
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1475
virtual bool is_serial() const
Definition: mesh_base.h:154
virtual void find_neighbors(const bool reset_remote_elements=false, const bool reset_current_list=true)=0
virtual void update_parallel_id_counts()=0
void clear_point_locator()
Definition: mesh_base.C:517
void libmesh_assert_valid_boundary_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1401
bool allow_renumbering() const
Definition: mesh_base.h:783
virtual void delete_remote_elements()
Definition: mesh_base.h:196
void cache_elem_dims()
Definition: mesh_base.C:574
void libmesh_assert_valid_unique_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1641
virtual void renumber_nodes_and_elements()=0

◆ print_info()

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

Prints relevant information about the mesh.

Definition at line 412 of file mesh_base.C.

References libMesh::MeshBase::get_info().

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

413 {
414  os << this->get_info()
415  << std::endl;
416 }
std::string get_info() const
Definition: mesh_base.C:378

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

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

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

102  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
processor_id_type rank() const
Definition: communicator.h:173

◆ query_elem() [1/2]

virtual const Elem* libMesh::MeshBase::query_elem ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A pointer to the $ i^{th} $ element, or nullptr if no such element exists in this processor's mesh data structure.
Deprecated:
Use the less confusingly-named query_elem_ptr() instead.

Definition at line 578 of file mesh_base.h.

References libMesh::MeshBase::query_elem_ptr().

579  {
580  libmesh_deprecated();
581  return this->query_elem_ptr(i);
582  }
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0

◆ query_elem() [2/2]

virtual Elem* libMesh::MeshBase::query_elem ( const dof_id_type  i)
inlinevirtualinherited
Returns
A writable pointer to the $ i^{th} $ element, or nullptr if no such element exists in this processor's mesh data structure.
Deprecated:
Use the less confusingly-named query_elem_ptr() instead.

Definition at line 592 of file mesh_base.h.

References libMesh::MeshBase::query_elem_ptr().

593  {
594  libmesh_deprecated();
595  return this->query_elem_ptr(i);
596  }
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0

◆ query_elem_ptr() [1/2]

const Elem * libMesh::DistributedMesh::query_elem_ptr ( const dof_id_type  i) const
overridevirtualinherited
Returns
A pointer to the $ i^{th} $ element, or nullptr if no such element exists in this processor's mesh data structure.

Implements libMesh::MeshBase.

Definition at line 353 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, and libMesh::DofObject::id().

354 {
355  std::map<dof_id_type, Elem *>::const_iterator it = _elements.find(i);
356  if (it != _elements.end().it)
357  {
358  const Elem * e = it->second;
359  libmesh_assert (!e || e->id() == i);
360  return e;
361  }
362 
363  return nullptr;
364 }
mapvector< Elem *, dof_id_type > _elements

◆ query_elem_ptr() [2/2]

Elem * libMesh::DistributedMesh::query_elem_ptr ( const dof_id_type  i)
overridevirtualinherited
Returns
A writable pointer to the $ i^{th} $ element, or nullptr if no such element exists in this processor's mesh data structure.

Implements libMesh::MeshBase.

Definition at line 369 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, and libMesh::DofObject::id().

370 {
371  std::map<dof_id_type, Elem *>::const_iterator it = _elements.find(i);
372  if (it != _elements.end().it)
373  {
374  Elem * e = _elements[i];
375  libmesh_assert (!e || e->id() == i);
376  return e;
377  }
378 
379  return nullptr;
380 }
mapvector< Elem *, dof_id_type > _elements

◆ query_node_ptr() [1/2]

const Node * libMesh::DistributedMesh::query_node_ptr ( const dof_id_type  i) const
overridevirtualinherited
Returns
A pointer to the $ i^{th} $ node, or nullptr if no such node exists in this processor's mesh data structure.

Implements libMesh::MeshBase.

Definition at line 299 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, and libMesh::DofObject::id().

300 {
301  std::map<dof_id_type, Node *>::const_iterator it = _nodes.find(i);
302  if (it != _nodes.end().it)
303  {
304  const Node * n = it->second;
305  libmesh_assert (!n || n->id() == i);
306  return n;
307  }
308 
309  return nullptr;
310 }
mapvector< Node *, dof_id_type > _nodes

◆ query_node_ptr() [2/2]

Node * libMesh::DistributedMesh::query_node_ptr ( const dof_id_type  i)
overridevirtualinherited
Returns
A writable pointer to the $ i^{th} $ node, or nullptr if no such node exists in this processor's mesh data structure.

Implements libMesh::MeshBase.

Definition at line 315 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, and libMesh::DofObject::id().

316 {
317  std::map<dof_id_type, Node *>::const_iterator it = _nodes.find(i);
318  if (it != _nodes.end().it)
319  {
320  Node * n = it->second;
321  libmesh_assert (!n || n->id() == i);
322  return n;
323  }
324 
325  return nullptr;
326 }
mapvector< Node *, dof_id_type > _nodes

◆ read()

void libMesh::UnstructuredMesh::read ( const std::string &  name,
void *  mesh_data = nullptr,
bool  skip_renumber_nodes_and_elements = false,
bool  skip_find_neighbors = false 
)
overridevirtualinherited

Reads the file specified by name. Attempts to figure out the proper method by the file extension. This is now the only way to read a mesh. The UnstructuredMesh then initializes its data structures and is ready for use.

The skip_renumber_nodes_and_elements argument is now deprecated - to disallow renumbering, set MeshBase::allow_renumbering(false).

Set skip_find_neighbors=true to skip the find-neighbors operation during prepare_for_use. This operation isn't always necessary and it can be time-consuming, which is why we provide an option to skip it.

Implements libMesh::MeshBase.

Definition at line 603 of file unstructured_mesh.C.

References libMesh::MeshBase::allow_renumbering(), libMesh::Quality::name(), libMesh::MeshBase::prepare_for_use(), and libMesh::NameBasedIO::read().

607 {
608  // Set the skip_renumber_nodes_and_elements flag on all processors
609  // if necessary.
610  // This ensures that renumber_nodes_and_elements is *not* called
611  // during prepare_for_use() for certain types of mesh files.
612  // This is required in cases where there is an associated solution
613  // file which expects a certain ordering of the nodes.
614  if (name.rfind(".gmv") + 4 == name.size())
615  this->allow_renumbering(false);
616 
617  NameBasedIO(*this).read(name);
618 
619  if (skip_renumber_nodes_and_elements)
620  {
621  // Use MeshBase::allow_renumbering() yourself instead.
622  libmesh_deprecated();
623  this->allow_renumbering(false);
624  }
625 
626  // Done reading the mesh. Now prepare it for use.
627  this->prepare_for_use(/*skip_renumber (deprecated)*/ false,
628  skip_find_neighbors);
629 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:152
bool allow_renumbering() const
Definition: mesh_base.h:783

◆ recalculate_n_partitions()

unsigned int libMesh::MeshBase::recalculate_n_partitions ( )
inherited

In a few (very rare) cases, the user may have manually tagged the elements with specific processor IDs by hand, without using a partitioner. In this case, the Mesh will not know that the total number of partitions, _n_parts, has changed, unless you call this function. This is an O(N active elements) calculation. The return value is the number of partitions, and _n_parts is also set by this function.

Definition at line 458 of file mesh_base.C.

References libMesh::MeshBase::_n_parts, libMesh::MeshBase::active_local_element_ptr_range(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem(), std::max(), libMesh::Parallel::Communicator::max(), and libMesh::DofObject::processor_id().

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

459 {
460  // This requires an inspection on every processor
461  parallel_object_only();
462 
463  unsigned int max_proc_id=0;
464 
465  for (const auto & elem : this->active_local_element_ptr_range())
466  max_proc_id = std::max(max_proc_id, static_cast<unsigned int>(elem->processor_id()));
467 
468  // The number of partitions is one more than the max processor ID.
469  _n_parts = max_proc_id+1;
470 
471  this->comm().max(_n_parts);
472 
473  return _n_parts;
474 }
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
const Parallel::Communicator & comm() const
long double max(long double a, double b)
virtual SimpleRange< element_iterator > active_local_element_ptr_range()=0
unsigned int _n_parts
Definition: mesh_base.h:1384
processor_id_type processor_id() const
Definition: dof_object.h:717

◆ redistribute()

void libMesh::DistributedMesh::redistribute ( )
overridevirtualinherited

Redistribute elements between processors. This gets called automatically by the Partitioner, and is a no-op in the case of a serialized mesh.

Reimplemented from libMesh::MeshBase.

Definition at line 803 of file distributed_mesh.C.

References libMesh::UnstructuredMesh::find_neighbors(), libMesh::DistributedMesh::is_serial(), libMesh::MeshCommunication::redistribute(), and libMesh::DistributedMesh::update_parallel_id_counts().

804 {
805  // If this is a truly parallel mesh, go through the redistribution/gather/delete remote steps
806  if (!this->is_serial())
807  {
808  // Construct a MeshCommunication object to actually redistribute the nodes
809  // and elements according to the partitioner, and then to re-gather the neighbors.
810  MeshCommunication mc;
811  mc.redistribute(*this);
812 
814 
815  // We probably had valid neighbors previously, so that a quality
816  // new partitioning could be found, but we might not have valid
817  // neighbor links on the newly-redistributed elements
818  this->find_neighbors();
819 
820  // Is this necessary? If we are called from prepare_for_use(), this will be called
821  // anyway... but users can always call partition directly, in which case we do need
822  // to call delete_remote_elements()...
823  //
824  // Regardless of whether it's necessary, it isn't safe. We
825  // haven't communicated new node processor_ids yet, and we can't
826  // delete nodes until we do.
827  // this->delete_remote_elements();
828  }
829 }
virtual void update_parallel_id_counts() override
virtual void find_neighbors(const bool reset_remote_elements=false, const bool reset_current_list=true) override
virtual bool is_serial() const override

◆ remove_ghosting_functor()

void libMesh::MeshBase::remove_ghosting_functor ( GhostingFunctor ghosting_functor)
inherited

Removes a functor which was previously added to the set of ghosting functors.

Definition at line 281 of file mesh_base.C.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::DofMap::clear(), libMesh::DofMap::remove_algebraic_ghosting_functor(), libMesh::DofMap::remove_coupling_functor(), and libMesh::DofMap::~DofMap().

282 {
283  _ghosting_functors.erase(&ghosting_functor);
284 }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1475

◆ renumber_dof_objects()

template<typename T >
dof_id_type libMesh::DistributedMesh::renumber_dof_objects ( mapvector< T *, dof_id_type > &  objects)
inherited

Renumber a parallel objects container.

Returns
The smallest globally unused id for that container.

Definition at line 961 of file distributed_mesh.C.

References libMesh::Parallel::Communicator::allgather(), libMesh::mapvector< Val, index_t >::begin(), libMesh::ParallelObject::comm(), data, libMesh::mapvector< Val, index_t >::end(), end, libMesh::mapvector< Val, index_t >::erase(), libMesh::index_range(), libMesh::DofObject::invalid_processor_id, libMesh::DofObject::invalid_unique_id, libMesh::ParallelObject::n_processors(), libMesh::MeshTools::Subdivision::next, libMesh::ParallelObject::processor_id(), and libMesh::Parallel::pull_parallel_vector_data().

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

962 {
963  // This function must be run on all processors at once
964  parallel_object_only();
965 
966  typedef typename mapvector<T *,dof_id_type>::veclike_iterator object_iterator;
967 
968  // In parallel we may not know what objects other processors have.
969  // Start by figuring out how many
970  dof_id_type unpartitioned_objects = 0;
971 
972  std::unordered_map<processor_id_type, dof_id_type>
973  ghost_objects_from_proc;
974 
975  object_iterator it = objects.begin();
976  object_iterator end = objects.end();
977 
978  while (it != end)
979  {
980  T * obj = *it;
981 
982  // Remove any nullptr container entries while we're here.
983  if (!obj)
984  it = objects.erase(it);
985  else
986  {
987  processor_id_type obj_procid = obj->processor_id();
988  if (obj_procid == DofObject::invalid_processor_id)
989  unpartitioned_objects++;
990  else
991  ghost_objects_from_proc[obj_procid]++;
992 
993  // Finally, increment the iterator
994  ++it;
995  }
996  }
997 
998  std::vector<dof_id_type> objects_on_proc(this->n_processors(), 0);
999  auto this_it = ghost_objects_from_proc.find(this->processor_id());
1000  this->comm().allgather
1001  ((this_it == ghost_objects_from_proc.end()) ? 0 : this_it->second,
1002  objects_on_proc);
1003 
1004 #ifndef NDEBUG
1005  libmesh_assert(this->comm().verify(unpartitioned_objects));
1006  for (processor_id_type p=0, np=this->n_processors(); p != np; ++p)
1007  if (ghost_objects_from_proc.count(p))
1008  libmesh_assert_less_equal (ghost_objects_from_proc[p], objects_on_proc[p]);
1009  else
1010  libmesh_assert_less_equal (0, objects_on_proc[p]);
1011 #endif
1012 
1013  // We'll renumber objects in blocks by processor id
1014  std::vector<dof_id_type> first_object_on_proc(this->n_processors());
1015  for (processor_id_type i=1; i != this->n_processors(); ++i)
1016  first_object_on_proc[i] = first_object_on_proc[i-1] +
1017  objects_on_proc[i-1];
1018  dof_id_type next_id = first_object_on_proc[this->processor_id()];
1019  dof_id_type first_free_id =
1020  first_object_on_proc[this->n_processors()-1] +
1021  objects_on_proc[this->n_processors()-1] +
1022  unpartitioned_objects;
1023 
1024  // First set new local object ids and build request sets
1025  // for non-local object ids
1026 
1027  // Request sets to send to each processor
1028  std::map<processor_id_type, std::vector<dof_id_type>>
1029  requested_ids;
1030 
1031  // We know how many objects live on each processor, so reserve() space for
1032  // each.
1033  auto ghost_end = ghost_objects_from_proc.end();
1034  for (processor_id_type p=0; p != this->n_processors(); ++p)
1035  if (p != this->processor_id())
1036  {
1037  const auto p_it = ghost_objects_from_proc.find(p);
1038  if (p_it != ghost_end)
1039  requested_ids[p].reserve(p_it->second);
1040  }
1041 
1042  end = objects.end();
1043  for (it = objects.begin(); it != end; ++it)
1044  {
1045  T * obj = *it;
1046  if (obj->processor_id() == this->processor_id())
1047  obj->set_id(next_id++);
1048  else if (obj->processor_id() != DofObject::invalid_processor_id)
1049  requested_ids[obj->processor_id()].push_back(obj->id());
1050  }
1051 
1052  // Next set ghost object ids from other processors
1053 
1054  auto gather_functor =
1055  [
1056 #ifndef NDEBUG
1057  this,
1058  &first_object_on_proc,
1059  &objects_on_proc,
1060 #endif
1061  &objects]
1062  (processor_id_type, const std::vector<dof_id_type> & ids,
1063  std::vector<dof_id_type> & new_ids)
1064  {
1065  std::size_t ids_size = ids.size();
1066  new_ids.resize(ids_size);
1067 
1068  for (std::size_t i=0; i != ids_size; ++i)
1069  {
1070  T * obj = objects[ids[i]];
1071  libmesh_assert(obj);
1072  libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
1073  new_ids[i] = obj->id();
1074 
1075  libmesh_assert_greater_equal (new_ids[i],
1076  first_object_on_proc[this->processor_id()]);
1077  libmesh_assert_less (new_ids[i],
1078  first_object_on_proc[this->processor_id()] +
1079  objects_on_proc[this->processor_id()]);
1080  }
1081  };
1082 
1083  auto action_functor =
1084  [
1085 #ifndef NDEBUG
1086  &first_object_on_proc,
1087  &objects_on_proc,
1088 #endif
1089  &objects]
1090  (processor_id_type libmesh_dbg_var(pid),
1091  const std::vector<dof_id_type> & ids,
1092  const std::vector<dof_id_type> & data)
1093  {
1094  // Copy the id changes we've now been informed of
1095  for (auto i : index_range(ids))
1096  {
1097  T * obj = objects[ids[i]];
1098  libmesh_assert (obj);
1099  libmesh_assert_equal_to (obj->processor_id(), pid);
1100  libmesh_assert_greater_equal (data[i],
1101  first_object_on_proc[pid]);
1102  libmesh_assert_less (data[i],
1103  first_object_on_proc[pid] +
1104  objects_on_proc[pid]);
1105  obj->set_id(data[i]);
1106  }
1107  };
1108 
1109  const dof_id_type * ex = nullptr;
1111  (this->comm(), requested_ids, gather_functor, action_functor, ex);
1112 
1113 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1114  auto unique_gather_functor =
1115  [
1116 #ifndef NDEBUG
1117  this,
1118 #endif
1119  &objects]
1120  (processor_id_type, const std::vector<dof_id_type> & ids,
1121  std::vector<unique_id_type> & data)
1122  {
1123  std::size_t ids_size = ids.size();
1124  data.resize(ids_size);
1125 
1126  for (std::size_t i=0; i != ids_size; ++i)
1127  {
1128  T * obj = objects[ids[i]];
1129  libmesh_assert(obj);
1130  libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
1131  data[i] = obj->valid_unique_id() ? obj->unique_id() : DofObject::invalid_unique_id;
1132  }
1133  };
1134 
1135  auto unique_action_functor =
1136  [&objects]
1137  (processor_id_type libmesh_dbg_var(pid),
1138  const std::vector<dof_id_type> & ids,
1139  const std::vector<unique_id_type> & data)
1140  {
1141  for (auto i : index_range(ids))
1142  {
1143  T * obj = objects[ids[i]];
1144  libmesh_assert (obj);
1145  libmesh_assert_equal_to (obj->processor_id(), pid);
1146  if (!obj->valid_unique_id() && data[i] != DofObject::invalid_unique_id)
1147  obj->set_unique_id() = (data[i]);
1148  }
1149  };
1150 
1151  const unique_id_type * unique_ex = nullptr;
1153  (this->comm(), requested_ids, unique_gather_functor,
1154  unique_action_functor, unique_ex);
1155 #endif
1156 
1157  // Next set unpartitioned object ids
1158  next_id = 0;
1159  for (processor_id_type i=0; i != this->n_processors(); ++i)
1160  next_id += objects_on_proc[i];
1161  for (it = objects.begin(); it != end; ++it)
1162  {
1163  T * obj = *it;
1164  if (obj->processor_id() == DofObject::invalid_processor_id)
1165  obj->set_id(next_id++);
1166  }
1167 
1168  // Finally shuffle around objects so that container indices
1169  // match ids
1170  it = objects.begin();
1171  end = objects.end();
1172  while (it != end)
1173  {
1174  T * obj = *it;
1175  if (obj) // don't try shuffling already-nullptr entries
1176  {
1177  T * next = objects[obj->id()];
1178  // If we have to move this object
1179  if (next != obj)
1180  {
1181  // nullptr out its original position for now
1182  // (our shuffling may put another object there shortly)
1183  *it = nullptr;
1184 
1185  // There may already be another object with this id that
1186  // needs to be moved itself
1187  while (next)
1188  {
1189  // We shouldn't be trying to give two objects the
1190  // same id
1191  libmesh_assert_not_equal_to (next->id(), obj->id());
1192  objects[obj->id()] = obj;
1193  obj = next;
1194  next = objects[obj->id()];
1195  }
1196  objects[obj->id()] = obj;
1197  }
1198  }
1199 
1200  // Remove any container entries that were left as nullptr.
1201  if (!obj)
1202  it = objects.erase(it);
1203  else
1204  ++it;
1205  }
1206 
1207  return first_free_id;
1208 }
void allgather(const T &send, std::vector< T, A > &recv) const
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Definition: int_range.h:104
uint8_t processor_id_type
Definition: id_types.h:99
const Parallel::Communicator & comm() const
IterBase * end
processor_id_type n_processors() const
void pull_parallel_vector_data(const Communicator &comm, const MapToVectors &queries, RequestContainer &reqs, GatherFunctor &gather_data, ActionFunctor &act_on_data, const datum *example)
static const unique_id_type invalid_unique_id
Definition: dof_object.h:352
static const processor_id_type invalid_processor_id
Definition: dof_object.h:358
static const unsigned int next[3]
IterBase * data
processor_id_type processor_id() const
uint8_t unique_id_type
Definition: id_types.h:79
uint8_t dof_id_type
Definition: id_types.h:64

◆ renumber_elem()

void libMesh::DistributedMesh::renumber_elem ( dof_id_type  old_id,
dof_id_type  new_id 
)
overridevirtualinherited

Changes the id of element old_id, both by changing elem(old_id)->id() and by moving elem(old_id) in the mesh's internal container. No element with the id new_id should already exist.

Implements libMesh::MeshBase.

Definition at line 543 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DofObject::id(), and libMesh::DofObject::set_id().

545 {
546  Elem * el = _elements[old_id];
547  libmesh_assert (el);
548  libmesh_assert_equal_to (el->id(), old_id);
549 
550  el->set_id(new_id);
551  libmesh_assert (!_elements[new_id]);
552  _elements[new_id] = el;
553  _elements.erase(old_id);
554 }
mapvector< Elem *, dof_id_type > _elements

◆ renumber_node()

void libMesh::DistributedMesh::renumber_node ( dof_id_type  old_id,
dof_id_type  new_id 
)
overridevirtualinherited

Changes the id of node old_id, both by changing node(old_id)->id() and by moving node(old_id) in the mesh's internal container. No element with the id new_id should already exist.

Implements libMesh::MeshBase.

Definition at line 729 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, libMesh::DofObject::id(), and libMesh::DofObject::set_id().

731 {
732  Node * nd = _nodes[old_id];
733  libmesh_assert (nd);
734  libmesh_assert_equal_to (nd->id(), old_id);
735 
736  nd->set_id(new_id);
737 
738  // If we have nodes shipped to this processor for NodeConstraints
739  // use, then those nodes will exist in _nodes, but may not be
740  // locatable via a TopologyMap due to the insufficiency of elements
741  // connecting to them. If local refinement then wants to create a
742  // *new* node in the same location, it will initially get a temporary
743  // id, and then make_node_ids_parallel_consistent() will try to move
744  // it to the canonical id. We need to account for this case to
745  // avoid false positives and memory leaks.
746 #ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
747  if (_nodes[new_id])
748  {
749  libmesh_assert_equal_to (*(Point *)_nodes[new_id],
750  *(Point *)_nodes[old_id]);
751  _nodes.erase(new_id);
752  }
753 #else
754  // If we aren't shipping nodes for NodeConstraints, there should be
755  // no reason for renumbering one node onto another.
756  libmesh_assert (!_nodes[new_id]);
757 #endif
758  _nodes[new_id] = nd;
759  _nodes.erase(old_id);
760 }
mapvector< Node *, dof_id_type > _nodes

◆ renumber_nodes_and_elements()

void libMesh::DistributedMesh::renumber_nodes_and_elements ( )
overridevirtualinherited

Remove nullptr elements from arrays.

Implements libMesh::MeshBase.

Definition at line 1211 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::elem(), libMesh::DistributedMesh::element_ptr_range(), end, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::DistributedMesh::max_elem_id(), libMesh::DistributedMesh::max_node_id(), libMesh::DistributedMesh::n_elem(), libMesh::DistributedMesh::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::node_id(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::BoundaryInfo::remove(), libMesh::DistributedMesh::renumber_dof_objects(), and libMesh::DistributedMesh::update_parallel_id_counts().

1212 {
1213  parallel_object_only();
1214 
1215 #ifdef DEBUG
1216  // Make sure our ids and flags are consistent
1220 #endif
1221 
1222  LOG_SCOPE("renumber_nodes_and_elements()", "DistributedMesh");
1223 
1224  std::set<dof_id_type> used_nodes;
1225 
1226  // flag the nodes we need
1227  for (auto & elem : this->element_ptr_range())
1228  for (unsigned int n=0; n != elem->n_nodes(); ++n)
1229  used_nodes.insert(elem->node_id(n));
1230 
1231  // Nodes not connected to any local elements, and nullptr node entries
1232  // in our container, are deleted
1233  {
1234  node_iterator_imp it = _nodes.begin();
1235  node_iterator_imp end = _nodes.end();
1236 
1237  while (it != end)
1238  {
1239  Node * nd = *it;
1240  if (!nd)
1241  it = _nodes.erase(it);
1242  else if (!used_nodes.count(nd->id()))
1243  {
1244  // remove any boundary information associated with
1245  // this node
1246  this->get_boundary_info().remove (nd);
1247 
1248  // delete the node
1249  delete nd;
1250 
1251  it = _nodes.erase(it);
1252  }
1253  else
1254  ++it;
1255  }
1256  }
1257 
1259  {
1260  this->update_parallel_id_counts();
1261  return;
1262  }
1263 
1264  // Finally renumber all the elements
1265  _n_elem = this->renumber_dof_objects (this->_elements);
1266 
1267  // and all the remaining nodes
1268  _n_nodes = this->renumber_dof_objects (this->_nodes);
1269 
1270  // And figure out what IDs we should use when adding new nodes and
1271  // new elements
1272  this->update_parallel_id_counts();
1273 
1274  // Make sure our caches are up to date and our
1275  // DofObjects are well packed
1276 #ifdef DEBUG
1277  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1278  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1279  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1280  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1281  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1282  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1283  libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1284  libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1285 
1286  // Make sure our ids and flags are consistent
1289 
1290  // And make sure we've made our numbering monotonic
1292 #endif
1293 }
virtual void update_parallel_id_counts() override
virtual dof_id_type parallel_n_nodes() const override
bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1431
mapvector< Elem *, dof_id_type > _elements
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
virtual void libmesh_assert_valid_parallel_ids() const override
virtual dof_id_type max_node_id() const override
void remove(const Node *node)
IterBase * end
void libmesh_assert_valid_parallel_flags() const
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:131
mapvector< Node *, dof_id_type >::veclike_iterator node_iterator_imp
void libmesh_assert_valid_parallel_p_levels() const
dof_id_type renumber_dof_objects(mapvector< T *, dof_id_type > &)
virtual dof_id_type parallel_n_elem() const override
mapvector< Node *, dof_id_type > _nodes
virtual unsigned int n_nodes() const =0
virtual dof_id_type n_nodes() const override
dof_id_type parallel_max_node_id() const
virtual dof_id_type n_elem() const override
virtual SimpleRange< element_iterator > element_ptr_range() override
virtual dof_id_type max_elem_id() const override
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:1914
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:64
void libmesh_assert_valid_elem_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1297

◆ reserve_elem()

virtual void libMesh::DistributedMesh::reserve_elem ( const dof_id_type  ne)
inlineoverridevirtualinherited

Reserves space for a known number of elements.

Note
This method may or may not do anything, depending on the actual Mesh implementation. If you know the number of elements you will add and call this method before repeatedly calling add_point() the implementation will be more efficient.

Implements libMesh::MeshBase.

Definition at line 225 of file distributed_mesh.h.

225 {}

◆ reserve_nodes()

virtual void libMesh::DistributedMesh::reserve_nodes ( const dof_id_type  nn)
inlineoverridevirtualinherited

Reserves space for a known number of nodes.

Note
This method may or may not do anything, depending on the actual Mesh implementation. If you know the number of nodes you will add and call this method before repeatedly calling add_point() the implementation will be more efficient.

Implements libMesh::MeshBase.

Definition at line 221 of file distributed_mesh.h.

221 {}

◆ semilocal_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::semilocal_elements_begin ( )
overridevirtualinherited

Iterate over elements for which elem->is_semilocal() is true for the current processor.

Implements libMesh::MeshBase.

◆ semilocal_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::semilocal_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ semilocal_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::semilocal_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ semilocal_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::semilocal_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ set_count_lower_dim_elems_in_point_locator()

void libMesh::MeshBase::set_count_lower_dim_elems_in_point_locator ( bool  count_lower_dim_elems)
inherited

In the point locator, do we count lower dimensional elements when we refine point locator regions? This is relevant in tree-based point locators, for example.

Definition at line 524 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

525 {
526  _count_lower_dim_elems_in_point_locator = count_lower_dim_elems;
527 }
bool _count_lower_dim_elems_in_point_locator
Definition: mesh_base.h:1404

◆ set_distributed()

virtual void libMesh::DistributedMesh::set_distributed ( )
inlineoverridevirtualinherited

Asserts that not all elements and nodes of the mesh necessarily exist on the current processor.

Reimplemented from libMesh::MeshBase.

Definition at line 133 of file distributed_mesh.h.

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

◆ set_mesh_dimension()

void libMesh::MeshBase::set_mesh_dimension ( unsigned char  d)
inlineinherited

Resets the logical dimension of the mesh. If the mesh has elements of multiple dimensions, this should be set to the largest dimension. E.g. if the mesh has 1D and 2D elements, this should be set to 2. If the mesh has 2D and 3D elements, this should be set to 3.

Definition at line 213 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GMVIO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), and libMesh::TriangleInterface::triangulate().

214  { _elem_dims.clear(); _elem_dims.insert(d); }
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1453

◆ set_n_partitions()

unsigned int& libMesh::MeshBase::set_n_partitions ( )
inlineprotectedinherited
Returns
A writable reference to the number of partitions.

Definition at line 1371 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

Referenced by libMesh::BoundaryInfo::sync().

1372  { return _n_parts; }
unsigned int _n_parts
Definition: mesh_base.h:1384

◆ set_next_unique_id()

void libMesh::MeshBase::set_next_unique_id ( unique_id_type  id)
inlineinherited

Sets the next unique id to be used.

Definition at line 310 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

310 { _next_unique_id = id; }
unique_id_type _next_unique_id
Definition: mesh_base.h:1418

◆ set_spatial_dimension()

void libMesh::MeshBase::set_spatial_dimension ( unsigned char  d)
inherited

Sets the "spatial dimension" of the Mesh. See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 142 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

143 {
144  // The user can set the _spatial_dimension however they wish,
145  // libMesh will only *increase* the spatial dimension, however,
146  // never decrease it.
147  _spatial_dimension = d;
148 }
unsigned char _spatial_dimension
Definition: mesh_base.h:1459

◆ set_subdomain_name_map()

std::map<subdomain_id_type, std::string>& libMesh::MeshBase::set_subdomain_name_map ( )
inlineinherited
Returns
A writable reference to the whole subdomain name map

Definition at line 1335 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_subdomain_names(), and libMesh::CheckpointIO::read_subdomain_names().

1336  { return _block_id_to_name; }
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1446

◆ skip_partitioning() [1/2]

void libMesh::MeshBase::skip_partitioning ( bool  skip)
inlineinherited

If true is passed in then this mesh will no longer be (re)partitioned. It would probably be a bad idea to call this on a DistributedMesh before the first partitioning has happened... because no elements would get assigned to your processor pool.

Note
Turning on skip_partitioning() can have adverse effects on your performance when using AMR... i.e. you could get large load imbalances. However you might still want to use this if the communication and computation of the rebalance and repartition is too high for your application.

It is also possible, for backwards-compatibility purposes, to skip partitioning by resetting the partitioner() pointer for this mesh.

Definition at line 811 of file mesh_base.h.

References libMesh::MeshBase::_skip_partitioning.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::MeshTools::correct_node_proc_ids().

811 { _skip_partitioning = skip; }

◆ skip_partitioning() [2/2]

bool libMesh::MeshBase::skip_partitioning ( ) const
inlineinherited

◆ spatial_dimension()

unsigned int libMesh::MeshBase::spatial_dimension ( ) const
inherited
Returns
The "spatial dimension" of the mesh.

The spatial dimension is defined as:

1 - for an exactly x-aligned mesh of 1D elements 2 - for an exactly x-y planar mesh of 2D elements 3 - otherwise

No tolerance checks are performed to determine whether the Mesh is x-aligned or x-y planar, only strict equality with zero in the higher dimensions is checked. Also, x-z and y-z planar meshes are considered to have spatial dimension == 3.

The spatial dimension is updated during prepare_for_use() based on the dimensions of the various elements present in the Mesh, but is never automatically decreased by this function.

For example, if the user calls set_spatial_dimension(2) and then later inserts 3D elements into the mesh, Mesh::spatial_dimension() will return 3 after the next call to prepare_for_use(). On the other hand, if the user calls set_spatial_dimension(3) and then inserts only x-aligned 1D elements into the Mesh, mesh.spatial_dimension() will remain 3.

Definition at line 135 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

Referenced by libMesh::MeshBase::get_info(), and libMesh::ExodusII_IO_Helper::initialize().

136 {
137  return cast_int<unsigned int>(_spatial_dimension);
138 }
unsigned char _spatial_dimension
Definition: mesh_base.h:1459

◆ sub_point_locator()

std::unique_ptr< PointLocatorBase > libMesh::MeshBase::sub_point_locator ( ) const
inherited
Returns
A pointer to a subordinate PointLocatorBase object for this mesh, constructing a master PointLocator first if necessary. This should not be used in threaded or non-parallel_only code unless the master has already been constructed.

Definition at line 496 of file mesh_base.C.

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

Referenced by libMesh::DofMap::create_dof_constraints(), libMesh::MeshFunction::init(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::DefaultCoupling::mesh_reinit(), libMesh::PointNeighborCoupling::mesh_reinit(), and libMesh::MeshRefinement::test_level_one().

497 {
498  // If there's no master point locator, then we need one.
499  if (_point_locator.get() == nullptr)
500  {
501  // PointLocator construction may not be safe within threads
502  libmesh_assert(!Threads::in_threads);
503 
504  // And it may require parallel communication
505  parallel_object_only();
506 
508  }
509 
510  // Otherwise there was a master point locator, and we can grab a
511  // sub-locator easily.
513 }
bool in_threads
Definition: threads.C:31
std::unique_ptr< PointLocatorBase > _point_locator
Definition: mesh_base.h:1398
static std::unique_ptr< PointLocatorBase > build(PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)

◆ subactive_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::subactive_elements_begin ( )
overridevirtualinherited

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

Implements libMesh::MeshBase.

◆ subactive_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::subactive_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ subactive_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::subactive_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ subactive_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::subactive_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ subdomain_ids()

void libMesh::MeshBase::subdomain_ids ( std::set< subdomain_id_type > &  ids) const
inherited

Constructs a list of all subdomain identifiers 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 288 of file mesh_base.C.

References libMesh::MeshBase::active_local_element_ptr_range(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem(), libMesh::Parallel::Communicator::set_union(), and libMesh::Elem::subdomain_id().

Referenced by libMesh::MeshBase::n_subdomains(), and libMesh::TecplotIO::TecplotIO().

289 {
290  // This requires an inspection on every processor
291  parallel_object_only();
292 
293  ids.clear();
294 
295  for (const auto & elem : this->active_local_element_ptr_range())
296  ids.insert(elem->subdomain_id());
297 
298  // Some subdomains may only live on other processors
299  this->comm().set_union(ids);
300 }
void set_union(T &data, const unsigned int root_id) const
virtual const Elem * elem(const dof_id_type i) const
Definition: mesh_base.h:537
const Parallel::Communicator & comm() const
virtual SimpleRange< element_iterator > active_local_element_ptr_range()=0
subdomain_id_type subdomain_id() const
Definition: elem.h:2034

◆ subdomain_name() [1/2]

std::string & libMesh::MeshBase::subdomain_name ( subdomain_id_type  id)
inherited
Returns
A writable reference for getting/setting an optional name for a subdomain.

Definition at line 538 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::AbaqusIO::assign_subdomain_ids(), DMlibMeshSetSystem_libMesh(), libMesh::UNVIO::groups_in(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::TecplotIO::write_binary(), and libMesh::ExodusII_IO_Helper::write_elements().

539 {
540  return _block_id_to_name[id];
541 }
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1446

◆ subdomain_name() [2/2]

const std::string & libMesh::MeshBase::subdomain_name ( subdomain_id_type  id) const
inherited

Definition at line 543 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

544 {
545  // An empty string to return when no matching subdomain name is found
546  static const std::string empty;
547 
548  std::map<subdomain_id_type, std::string>::const_iterator iter = _block_id_to_name.find(id);
549  if (iter == _block_id_to_name.end())
550  return empty;
551  else
552  return iter->second;
553 }
std::map< subdomain_id_type, std::string > _block_id_to_name
Definition: mesh_base.h:1446

◆ type_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::type_elements_begin ( ElemType  type)
overridevirtualinherited

Iterate over all elements with a specified geometric type.

Implements libMesh::MeshBase.

◆ type_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::type_elements_begin ( ElemType  type) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ type_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::type_elements_end ( ElemType  type)
overridevirtualinherited

Implements libMesh::MeshBase.

◆ type_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::type_elements_end ( ElemType  type) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ unpartitioned_elements_begin() [1/2]

virtual element_iterator libMesh::DistributedMesh::unpartitioned_elements_begin ( )
overridevirtualinherited

Iterate over unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

◆ unpartitioned_elements_begin() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::unpartitioned_elements_begin ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ unpartitioned_elements_end() [1/2]

virtual element_iterator libMesh::DistributedMesh::unpartitioned_elements_end ( )
overridevirtualinherited

Implements libMesh::MeshBase.

◆ unpartitioned_elements_end() [2/2]

virtual const_element_iterator libMesh::DistributedMesh::unpartitioned_elements_end ( ) const
overridevirtualinherited

Implements libMesh::MeshBase.

◆ update_parallel_id_counts()

void libMesh::DistributedMesh::update_parallel_id_counts ( )
overridevirtualinherited

Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors

Implements libMesh::MeshBase.

Definition at line 127 of file distributed_mesh.C.

References 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::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::ParallelObject::n_processors(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), and libMesh::ParallelObject::processor_id().

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

128 {
129  // This function must be run on all processors at once
130  parallel_object_only();
131 
132  _n_elem = this->parallel_n_elem();
133  _n_nodes = this->parallel_n_nodes();
136 
139  ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
140  (this->n_processors() + 1) + this->n_processors();
143  ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
144  (this->n_processors() + 1) + this->processor_id();
145 
148  ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
149  (this->n_processors() + 1) + this->n_processors();
152  ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
153  (this->n_processors() + 1) + this->processor_id();
154 
155 #ifdef LIBMESH_ENABLE_UNIQUE_ID
158  ((_next_unique_id-1) / (this->n_processors() + 1) + 1) *
159  (this->n_processors() + 1) + this->n_processors();
161  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
162  (this->n_processors() + 1) + this->processor_id();
163 #endif
164 }
virtual dof_id_type parallel_n_nodes() const override
dof_id_type _next_free_local_node_id
virtual unique_id_type parallel_max_unique_id() const override
unique_id_type _next_unique_id
Definition: mesh_base.h:1418
processor_id_type n_processors() const
virtual dof_id_type parallel_n_elem() const override
dof_id_type parallel_max_node_id() const
dof_id_type _next_free_unpartitioned_node_id
dof_id_type _next_free_unpartitioned_elem_id
unique_id_type _next_unpartitioned_unique_id
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id
dof_id_type parallel_max_elem_id() const

◆ update_post_partitioning()

void libMesh::DistributedMesh::update_post_partitioning ( )
overridevirtualinherited

Recalculate cached data after elements and nodes have been repartitioned.

Reimplemented from libMesh::MeshBase.

Definition at line 833 of file distributed_mesh.C.

References libMesh::DistributedMesh::update_parallel_id_counts().

834 {
835  // this->recalculate_n_partitions();
836 
837  // Partitioning changes our numbers of unpartitioned objects
839 }
virtual void update_parallel_id_counts() override

◆ write() [1/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name)
overridevirtualinherited

Write the file specified by name. Attempts to figure out the proper method by the file extension.

Implements libMesh::MeshBase.

Definition at line 633 of file unstructured_mesh.C.

References libMesh::Quality::name(), and libMesh::NameBasedIO::write().

634 {
635  LOG_SCOPE("write()", "Mesh");
636 
637  NameBasedIO(*this).write(name);
638 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42

◆ write() [2/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name,
const std::vector< Number > &  values,
const std::vector< std::string > &  variable_names 
)
inherited

Write to the file specified by name. Attempts to figure out the proper method by the file extension. Also writes data.

Definition at line 642 of file unstructured_mesh.C.

References libMesh::Quality::name(), and libMesh::NameBasedIO::write_nodal_data().

645 {
646  LOG_SCOPE("write()", "Mesh");
647 
648  NameBasedIO(*this).write_nodal_data(name, v, vn);
649 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42

Member Data Documentation

◆ _allow_remote_element_removal

bool libMesh::MeshBase::_allow_remote_element_removal
protectedinherited

If this is false then even on DistributedMesh remote elements will not be deleted during mesh preparation.

This is true by default.

Definition at line 1439 of file mesh_base.h.

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

◆ _block_id_to_name

std::map<subdomain_id_type, std::string> libMesh::MeshBase::_block_id_to_name
protectedinherited

This structure maintains the mapping of named blocks for file formats that support named blocks. Currently this is only implemented for ExodusII

Definition at line 1446 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_id_by_name(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::MeshBase::set_subdomain_name_map(), and libMesh::MeshBase::subdomain_name().

◆ _communicator

◆ _count_lower_dim_elems_in_point_locator

bool libMesh::MeshBase::_count_lower_dim_elems_in_point_locator
protectedinherited

Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based point locators, for example.

Definition at line 1404 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator(), and libMesh::MeshBase::set_count_lower_dim_elems_in_point_locator().

◆ _default_ghosting

std::unique_ptr<GhostingFunctor> libMesh::MeshBase::_default_ghosting
protectedinherited

The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior. We use a base class pointer here to avoid dragging in more header dependencies.

Definition at line 1466 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_ghosting(), and libMesh::MeshBase::MeshBase().

◆ _elem_dims

std::set<unsigned char> libMesh::MeshBase::_elem_dims
protectedinherited

We cache the dimension of the elements present in the mesh. So, if we have a mesh with 1D and 2D elements, this structure will contain 1 and 2.

Definition at line 1453 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_dims(), libMesh::MeshBase::clear(), libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::get_info(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::MeshBase(), and libMesh::MeshBase::set_mesh_dimension().

◆ _elements

◆ _extra_ghost_elems

std::set<Elem *> libMesh::DistributedMesh::_extra_ghost_elems
protectedinherited

◆ _ghosting_functors

std::set<GhostingFunctor *> libMesh::MeshBase::_ghosting_functors
protectedinherited

◆ _is_prepared

bool libMesh::MeshBase::_is_prepared
protectedinherited

◆ _is_serial

◆ _is_serial_on_proc_0

bool libMesh::DistributedMesh::_is_serial_on_proc_0
protectedinherited

◆ _max_elem_id

◆ _max_node_id

◆ _n_elem

◆ _n_nodes

◆ _n_parts

unsigned int libMesh::MeshBase::_n_parts
protectedinherited

The number of partitions the mesh has. This is set by the partitioners, and may not be changed directly by the user.

Note
The number of partitions need not equal this->n_processors(), consider for example the case where you simply want to partition a mesh on one processor and view the result in GMV.

Definition at line 1384 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::n_partitions(), libMesh::MeshBase::recalculate_n_partitions(), and libMesh::MeshBase::set_n_partitions().

◆ _next_free_local_elem_id

◆ _next_free_local_node_id

dof_id_type libMesh::DistributedMesh::_next_free_local_node_id
protectedinherited

Guaranteed globally unused IDs for use when adding new nodes or elements.

Definition at line 554 of file distributed_mesh.h.

Referenced by libMesh::DistributedMesh::add_node(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::DistributedMesh(), and libMesh::DistributedMesh::update_parallel_id_counts().

◆ _next_free_unpartitioned_elem_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_elem_id
protectedinherited

◆ _next_free_unpartitioned_node_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_node_id
protectedinherited

◆ _next_unique_id

◆ _next_unpartitioned_unique_id

unique_id_type libMesh::DistributedMesh::_next_unpartitioned_unique_id
protectedinherited

◆ _nodes

◆ _partitioner

std::unique_ptr<Partitioner> libMesh::MeshBase::_partitioner
protectedinherited

A partitioner to use at each prepare_for_use().

This will be built in the constructor of each derived class, but can be replaced by the user through the partitioner() accessor.

Definition at line 1412 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::partitioner(), libMesh::ReplicatedMesh::ReplicatedMesh(), and libMesh::MeshBase::skip_partitioning().

◆ _point_locator

std::unique_ptr<PointLocatorBase> libMesh::MeshBase::_point_locator
mutableprotectedinherited

A PointLocator class for this mesh. This will not actually be built unless needed. Further, since we want our point_locator() method to be const (yet do the dynamic allocating) this needs to be mutable. Since the PointLocatorBase::build() member is used, and it operates on a constant reference to the mesh, this is OK.

Definition at line 1398 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear_point_locator(), libMesh::MeshBase::point_locator(), and libMesh::MeshBase::sub_point_locator().

◆ _skip_partitioning

bool libMesh::MeshBase::_skip_partitioning
protectedinherited

If this is true then no partitioning should be done.

Definition at line 1424 of file mesh_base.h.

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

◆ _skip_renumber_nodes_and_elements

bool libMesh::MeshBase::_skip_renumber_nodes_and_elements
protectedinherited

If this is true then renumbering will be kept to a minimum.

This is set when prepare_for_use() is called.

Definition at line 1431 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_renumbering(), libMesh::MeshBase::prepare_for_use(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

◆ _spatial_dimension

unsigned char libMesh::MeshBase::_spatial_dimension
protectedinherited

The "spatial dimension" of the Mesh. See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 1459 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_dims(), libMesh::MeshBase::set_spatial_dimension(), and libMesh::MeshBase::spatial_dimension().

◆ boundary_info

std::unique_ptr<BoundaryInfo> libMesh::MeshBase::boundary_info
inherited

This class holds the boundary information. It can store nodes, edges, and faces with a corresponding id that facilitates setting boundary conditions.

Direct access to this class will be removed in future libMesh versions. Use the get_boundary_info() accessor instead.

Definition at line 1363 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), and libMesh::MeshBase::get_boundary_info().


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