libMesh::UnstructuredMesh Class Referenceabstract

Base class for Replicated and Distributed meshes. More...

#include <unstructured_mesh.h>

Inheritance diagram for libMesh::UnstructuredMesh:

Public Types

typedef Predicates::multi_predicate Predicate
 

Public Member Functions

 UnstructuredMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
 
 UnstructuredMesh (unsigned char dim=1)
 
virtual ~UnstructuredMesh ()
 
virtual void read (const std::string &name, void *mesh_data=libmesh_nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) libmesh_override
 
virtual void write (const std::string &name) libmesh_override
 
void write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names)
 
virtual void all_first_order () libmesh_override
 
virtual void all_second_order (const bool full_ordered=true) libmesh_override
 
void create_pid_mesh (UnstructuredMesh &pid_mesh, const processor_id_type pid) const
 
void create_submesh (UnstructuredMesh &new_mesh, const_element_iterator &it, const const_element_iterator &it_end) const
 
virtual void copy_nodes_and_elements (const UnstructuredMesh &other_mesh, const bool skip_find_neighbors=false)
 
virtual void find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) libmesh_override
 
virtual bool contract () libmesh_override
 
virtual UniquePtr< MeshBaseclone () const =0
 
virtual UniquePtr< Partitioner > & partitioner ()
 
const BoundaryInfoget_boundary_info () const
 
BoundaryInfoget_boundary_info ()
 
virtual void clear ()
 
bool is_prepared () const
 
virtual bool is_serial () const
 
virtual void set_distributed ()
 
virtual bool is_replicated () const
 
virtual void allgather ()
 
virtual void gather_to_zero ()
 
virtual void delete_remote_elements ()
 
unsigned int mesh_dimension () const
 
void set_mesh_dimension (unsigned char d)
 
const std::set< unsigned char > & elem_dimensions () const
 
unsigned int spatial_dimension () const
 
void set_spatial_dimension (unsigned char d)
 
virtual dof_id_type n_nodes () const =0
 
virtual dof_id_type parallel_n_nodes () const =0
 
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
 
virtual dof_id_type max_node_id () const =0
 
unique_id_type next_unique_id ()
 
void set_next_unique_id (unique_id_type id)
 
virtual void reserve_nodes (const dof_id_type nn)=0
 
virtual dof_id_type n_elem () const =0
 
virtual dof_id_type parallel_n_elem () const =0
 
virtual dof_id_type max_elem_id () const =0
 
virtual unique_id_type parallel_max_unique_id () const =0
 
virtual void reserve_elem (const dof_id_type ne)=0
 
virtual void update_parallel_id_counts ()=0
 
virtual dof_id_type n_active_elem () const =0
 
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 Pointpoint (const dof_id_type i) const =0
 
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 Nodenode_ptr (const dof_id_type i) const =0
 
virtual Nodenode_ptr (const dof_id_type i)=0
 
virtual const Nodequery_node_ptr (const dof_id_type i) const =0
 
virtual Nodequery_node_ptr (const dof_id_type i)=0
 
virtual const Elemelem_ref (const dof_id_type i) const
 
virtual Elemelem_ref (const dof_id_type i)
 
virtual const Elemelem_ptr (const dof_id_type i) const =0
 
virtual Elemelem_ptr (const dof_id_type i)=0
 
virtual const Elemelem (const dof_id_type i) const
 
virtual Elemelem (const dof_id_type i)
 
virtual const Elemquery_elem_ptr (const dof_id_type i) const =0
 
virtual Elemquery_elem_ptr (const dof_id_type i)=0
 
virtual const Elemquery_elem (const dof_id_type i) const
 
virtual Elemquery_elem (const dof_id_type i)
 
virtual Nodeadd_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
 
virtual Nodeadd_node (Node *n)=0
 
virtual Nodeinsert_node (Node *n)=0
 
virtual void delete_node (Node *n)=0
 
virtual void renumber_node (dof_id_type old_id, dof_id_type new_id)=0
 
virtual Elemadd_elem (Elem *e)=0
 
virtual Eleminsert_elem (Elem *e)=0
 
virtual void delete_elem (Elem *e)=0
 
virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id)=0
 
virtual void renumber_nodes_and_elements ()=0
 
virtual void fix_broken_node_and_element_numbering ()=0
 
void prepare_for_use (const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
 
virtual void partition (const unsigned int n_parts)
 
void partition ()
 
virtual void redistribute ()
 
virtual void update_post_partitioning ()
 
void allow_renumbering (bool allow)
 
bool allow_renumbering () const
 
void allow_remote_element_removal (bool allow)
 
bool allow_remote_element_removal () const
 
void skip_partitioning (bool skip)
 
bool skip_partitioning () const
 
void add_ghosting_functor (GhostingFunctor &ghosting_functor)
 
void remove_ghosting_functor (GhostingFunctor &ghosting_functor)
 
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin () const
 
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end () const
 
void subdomain_ids (std::set< subdomain_id_type > &ids) const
 
subdomain_id_type n_subdomains () const
 
unsigned int n_partitions () const
 
std::string get_info () const
 
void print_info (std::ostream &os=libMesh::out) const
 
unsigned int recalculate_n_partitions ()
 
const PointLocatorBasepoint_locator () const
 
UniquePtr< PointLocatorBasesub_point_locator () const
 
void clear_point_locator ()
 
void set_count_lower_dim_elems_in_point_locator (bool count_lower_dim_elems)
 
bool get_count_lower_dim_elems_in_point_locator () const
 
virtual void libmesh_assert_valid_parallel_ids () const
 
std::string & subdomain_name (subdomain_id_type id)
 
const std::string & subdomain_name (subdomain_id_type id) const
 
subdomain_id_type get_id_by_name (const std::string &name) const
 
virtual element_iterator elements_begin ()=0
 
virtual const_element_iterator elements_begin () const =0
 
virtual element_iterator elements_end ()=0
 
virtual const_element_iterator elements_end () const =0
 
virtual element_iterator ancestor_elements_begin ()=0
 
virtual const_element_iterator ancestor_elements_begin () const =0
 
virtual element_iterator ancestor_elements_end ()=0
 
virtual const_element_iterator ancestor_elements_end () const =0
 
virtual element_iterator subactive_elements_begin ()=0
 
virtual const_element_iterator subactive_elements_begin () const =0
 
virtual element_iterator subactive_elements_end ()=0
 
virtual const_element_iterator subactive_elements_end () const =0
 
virtual element_iterator semilocal_elements_begin ()=0
 
virtual const_element_iterator semilocal_elements_begin () const =0
 
virtual element_iterator semilocal_elements_end ()=0
 
virtual const_element_iterator semilocal_elements_end () const =0
 
virtual element_iterator facelocal_elements_begin ()=0
 
virtual const_element_iterator facelocal_elements_begin () const =0
 
virtual element_iterator facelocal_elements_end ()=0
 
virtual const_element_iterator facelocal_elements_end () const =0
 
virtual element_iterator level_elements_begin (unsigned int level)=0
 
virtual const_element_iterator level_elements_begin (unsigned int level) const =0
 
virtual element_iterator level_elements_end (unsigned int level)=0
 
virtual const_element_iterator level_elements_end (unsigned int level) const =0
 
virtual element_iterator pid_elements_begin (processor_id_type proc_id)=0
 
virtual const_element_iterator pid_elements_begin (processor_id_type proc_id) const =0
 
virtual element_iterator pid_elements_end (processor_id_type proc_id)=0
 
virtual const_element_iterator pid_elements_end (processor_id_type proc_id) const =0
 
virtual element_iterator type_elements_begin (ElemType type)=0
 
virtual const_element_iterator type_elements_begin (ElemType type) const =0
 
virtual element_iterator type_elements_end (ElemType type)=0
 
virtual const_element_iterator type_elements_end (ElemType type) const =0
 
virtual element_iterator unpartitioned_elements_begin ()=0
 
virtual const_element_iterator unpartitioned_elements_begin () const =0
 
virtual element_iterator unpartitioned_elements_end ()=0
 
virtual const_element_iterator unpartitioned_elements_end () const =0
 
virtual element_iterator active_unpartitioned_elements_begin ()=0
 
virtual const_element_iterator active_unpartitioned_elements_begin () const =0
 
virtual element_iterator active_unpartitioned_elements_end ()=0
 
virtual const_element_iterator active_unpartitioned_elements_end () const =0
 
virtual element_iterator ghost_elements_begin ()=0
 
virtual const_element_iterator ghost_elements_begin () const =0
 
virtual element_iterator ghost_elements_end ()=0
 
virtual const_element_iterator ghost_elements_end () const =0
 
virtual element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint)=0
 
virtual const_element_iterator evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const =0
 
virtual element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint)=0
 
virtual const_element_iterator evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const =0
 
virtual element_iterator flagged_elements_begin (unsigned char rflag)=0
 
virtual const_element_iterator flagged_elements_begin (unsigned char rflag) const =0
 
virtual element_iterator flagged_elements_end (unsigned char rflag)=0
 
virtual const_element_iterator flagged_elements_end (unsigned char rflag) const =0
 
virtual element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid)=0
 
virtual const_element_iterator flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) const =0
 
virtual element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid)=0
 
virtual const_element_iterator flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) const =0
 
virtual element_iterator active_elements_begin ()=0
 
virtual const_element_iterator active_elements_begin () const =0
 
virtual element_iterator active_elements_end ()=0
 
virtual const_element_iterator active_elements_end () const =0
 
virtual element_iterator local_elements_begin ()=0
 
virtual const_element_iterator local_elements_begin () const =0
 
virtual element_iterator local_elements_end ()=0
 
virtual const_element_iterator local_elements_end () const =0
 
virtual element_iterator active_semilocal_elements_begin ()=0
 
virtual const_element_iterator active_semilocal_elements_begin () const =0
 
virtual element_iterator active_semilocal_elements_end ()=0
 
virtual const_element_iterator active_semilocal_elements_end () const =0
 
virtual element_iterator active_type_elements_begin (ElemType type)=0
 
virtual const_element_iterator active_type_elements_begin (ElemType type) const =0
 
virtual element_iterator active_type_elements_end (ElemType type)=0
 
virtual const_element_iterator active_type_elements_end (ElemType type) const =0
 
virtual element_iterator active_pid_elements_begin (processor_id_type proc_id)=0
 
virtual const_element_iterator active_pid_elements_begin (processor_id_type proc_id) const =0
 
virtual element_iterator active_pid_elements_end (processor_id_type proc_id)=0
 
virtual const_element_iterator active_pid_elements_end (processor_id_type proc_id) const =0
 
virtual element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id)=0
 
virtual const_element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) const =0
 
virtual element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id)=0
 
virtual const_element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) const =0
 
virtual element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss)=0
 
virtual const_element_iterator active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) const =0
 
virtual element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss)=0
 
virtual const_element_iterator active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) const =0
 
virtual element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id)=0
 
virtual const_element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const =0
 
virtual element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id)=0
 
virtual const_element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const =0
 
virtual element_iterator local_level_elements_begin (unsigned int level)=0
 
virtual const_element_iterator local_level_elements_begin (unsigned int level) const =0
 
virtual element_iterator local_level_elements_end (unsigned int level)=0
 
virtual const_element_iterator local_level_elements_end (unsigned int level) const =0
 
virtual element_iterator local_not_level_elements_begin (unsigned int level)=0
 
virtual const_element_iterator local_not_level_elements_begin (unsigned int level) const =0
 
virtual element_iterator local_not_level_elements_end (unsigned int level)=0
 
virtual const_element_iterator local_not_level_elements_end (unsigned int level) const =0
 
virtual element_iterator not_level_elements_begin (unsigned int level)=0
 
virtual const_element_iterator not_level_elements_begin (unsigned int level) const =0
 
virtual element_iterator not_level_elements_end (unsigned int level)=0
 
virtual const_element_iterator not_level_elements_end (unsigned int level) const =0
 
virtual element_iterator active_local_elements_begin ()=0
 
virtual const_element_iterator active_local_elements_begin () const =0
 
virtual element_iterator active_local_elements_end ()=0
 
virtual const_element_iterator active_local_elements_end () const =0
 
virtual element_iterator active_not_local_elements_begin ()=0
 
virtual const_element_iterator active_not_local_elements_begin () const =0
 
virtual element_iterator active_not_local_elements_end ()=0
 
virtual const_element_iterator active_not_local_elements_end () const =0
 
virtual element_iterator not_local_elements_begin ()=0
 
virtual const_element_iterator not_local_elements_begin () const =0
 
virtual element_iterator not_local_elements_end ()=0
 
virtual const_element_iterator not_local_elements_end () const =0
 
virtual element_iterator not_subactive_elements_begin ()=0
 
virtual const_element_iterator not_subactive_elements_begin () const =0
 
virtual element_iterator not_subactive_elements_end ()=0
 
virtual const_element_iterator not_subactive_elements_end () const =0
 
virtual element_iterator not_active_elements_begin ()=0
 
virtual const_element_iterator not_active_elements_begin () const =0
 
virtual element_iterator not_active_elements_end ()=0
 
virtual const_element_iterator not_active_elements_end () const =0
 
virtual element_iterator not_ancestor_elements_begin ()=0
 
virtual const_element_iterator not_ancestor_elements_begin () const =0
 
virtual element_iterator not_ancestor_elements_end ()=0
 
virtual const_element_iterator not_ancestor_elements_end () const =0
 
virtual node_iterator nodes_begin ()=0
 
virtual const_node_iterator nodes_begin () const =0
 
virtual node_iterator nodes_end ()=0
 
virtual const_node_iterator nodes_end () const =0
 
virtual node_iterator active_nodes_begin ()=0
 
virtual const_node_iterator active_nodes_begin () const =0
 
virtual node_iterator active_nodes_end ()=0
 
virtual const_node_iterator active_nodes_end () const =0
 
virtual node_iterator local_nodes_begin ()=0
 
virtual const_node_iterator local_nodes_begin () const =0
 
virtual node_iterator local_nodes_end ()=0
 
virtual const_node_iterator local_nodes_end () const =0
 
virtual node_iterator pid_nodes_begin (processor_id_type proc_id)=0
 
virtual const_node_iterator pid_nodes_begin (processor_id_type proc_id) const =0
 
virtual node_iterator pid_nodes_end (processor_id_type proc_id)=0
 
virtual const_node_iterator pid_nodes_end (processor_id_type proc_id) const =0
 
virtual node_iterator bid_nodes_begin (boundary_id_type bndry_id)=0
 
virtual const_node_iterator bid_nodes_begin (boundary_id_type bndry_id) const =0
 
virtual node_iterator bid_nodes_end (boundary_id_type bndry_id)=0
 
virtual const_node_iterator bid_nodes_end (boundary_id_type bndry_id) const =0
 
virtual node_iterator bnd_nodes_begin ()=0
 
virtual const_node_iterator bnd_nodes_begin () const =0
 
virtual node_iterator bnd_nodes_end ()=0
 
virtual const_node_iterator bnd_nodes_end () const =0
 
virtual node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint)=0
 
virtual const_node_iterator evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const =0
 
virtual node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint)=0
 
virtual const_node_iterator evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const =0
 
std::map< subdomain_id_type, std::string > & set_subdomain_name_map ()
 
const std::map< subdomain_id_type, std::string > & get_subdomain_name_map () const
 
void cache_elem_dims ()
 
void detect_interior_parents ()
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Public Attributes

UniquePtr< BoundaryInfoboundary_info
 

Protected Member Functions

unsigned int & set_n_partitions ()
 

Protected Attributes

unsigned int _n_parts
 
bool _is_prepared
 
UniquePtr< PointLocatorBase_point_locator
 
bool _count_lower_dim_elems_in_point_locator
 
UniquePtr< Partitioner_partitioner
 
unique_id_type _next_unique_id
 
bool _skip_partitioning
 
bool _skip_renumber_nodes_and_elements
 
bool _allow_remote_element_removal
 
std::map< subdomain_id_type, std::string > _block_id_to_name
 
std::set< unsigned char > _elem_dims
 
unsigned char _spatial_dimension
 
UniquePtr< GhostingFunctor_default_ghosting
 
std::set< GhostingFunctor * > _ghosting_functors
 
const Parallel::Communicator_communicator
 

Detailed Description

Base class for Replicated and Distributed meshes.

The UnstructuredMesh class is derived from the MeshBase class. The user will typically want to instantiate and use the Mesh class in her applications, which is currently a simple derived class of UnstructuredMesh. In order to use the adaptive mesh refinment capabilities of the library, first instantiate a MeshRefinement object with a reference to this class. Then call the appropriate refinement functions from that object. To interact with the boundary, instantiate a BoundaryMesh with a reference to this class, and then use that object's functionality.

Author
Roy Stogner
Date
2007

Definition at line 48 of file unstructured_mesh.h.

Member Typedef Documentation

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

Definition at line 867 of file mesh_base.h.

Constructor & Destructor Documentation

libMesh::UnstructuredMesh::UnstructuredMesh ( const Parallel::Communicator comm_in,
unsigned char  dim = 1 
)
explicit

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

Definition at line 51 of file unstructured_mesh.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

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

52  :
53  MeshBase (comm_in,d)
54 {
56 }
libmesh_assert(j)
MeshBase(const Parallel::Communicator &comm_in, unsigned char dim=1)
Definition: mesh_base.C:50
bool initialized()
Definition: libmesh.C:272
libMesh::UnstructuredMesh::UnstructuredMesh ( unsigned char  dim = 1)

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

Deprecated:
LIBMESH_DISABLE_COMMWORLD is now the default, use the constructor that takes a Parallel::Communicator instead.

Definition at line 61 of file unstructured_mesh.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

61  :
62  MeshBase (d)
63 {
64  libmesh_deprecated();
66 }
libmesh_assert(j)
MeshBase(const Parallel::Communicator &comm_in, unsigned char dim=1)
Definition: mesh_base.C:50
bool initialized()
Definition: libmesh.C:272
libMesh::UnstructuredMesh::~UnstructuredMesh ( )
virtual

Destructor.

Definition at line 225 of file unstructured_mesh.C.

References libMesh::closed().

226 {
227  // this->clear (); // Nothing to clear at this level
228 
229  libmesh_exceptionless_assert (!libMesh::closed());
230 }
bool closed()
Definition: libmesh.C:279

Member Function Documentation

virtual element_iterator libMesh::MeshBase::active_elements_begin ( )
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::LinearPartitioner::_do_partition(), libMesh::MetisPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::MappedSubdomainPartitioner::_do_partition(), libMesh::MeshRefinement::_refine_elements(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshBase::cache_elem_dims(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::detect_interior_parents(), libMesh::MeshTools::Modification::distort(), DMlibMeshSetSystem_libMesh(), libMesh::TecplotIO::elem_dimension(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::LocationMap< T >::fill(), libMesh::MeshTools::find_boundary_nodes(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshTools::Modification::flatten(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::UNVIO::groups_in(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DofMap::invalidate_dofs(), libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::MeshBase::n_active_sub_elem(), libMesh::PointLocatorTree::perform_fuzzy_linear_search(), libMesh::PointLocatorTree::perform_linear_search(), libMesh::VariationalMeshSmoother::readgr(), libMesh::DofMap::reinit(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Tree< N >::Tree(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::MeshRefinement::uniformly_p_coarsen(), libMesh::MeshRefinement::uniformly_p_refine(), libMesh::MeshRefinement::uniformly_refine(), libMesh::FroIO::write(), libMesh::PostscriptIO::write(), libMesh::TetGenIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::GmshIO::write_post(), and libMesh::GnuPlotIO::write_solution().

virtual const_element_iterator libMesh::MeshBase::active_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_elements_end ( )
pure virtualinherited

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::LinearPartitioner::_do_partition(), libMesh::MetisPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::MappedSubdomainPartitioner::_do_partition(), libMesh::MeshRefinement::_refine_elements(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshBase::cache_elem_dims(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::detect_interior_parents(), libMesh::MeshTools::Modification::distort(), DMlibMeshSetSystem_libMesh(), libMesh::TecplotIO::elem_dimension(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::LocationMap< T >::fill(), libMesh::MeshTools::find_boundary_nodes(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshTools::Modification::flatten(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::UNVIO::groups_in(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DofMap::invalidate_dofs(), libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::MeshBase::n_active_sub_elem(), libMesh::PointLocatorTree::perform_fuzzy_linear_search(), libMesh::PointLocatorTree::perform_linear_search(), libMesh::VariationalMeshSmoother::readgr(), libMesh::DofMap::reinit(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Tree< N >::Tree(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::MeshRefinement::uniformly_p_coarsen(), libMesh::MeshRefinement::uniformly_p_refine(), libMesh::MeshRefinement::uniformly_refine(), libMesh::FroIO::write(), libMesh::PostscriptIO::write(), libMesh::TetGenIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::GmshIO::write_post(), and libMesh::GnuPlotIO::write_solution().

virtual const_element_iterator libMesh::MeshBase::active_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_local_elements_begin ( )
pure virtualinherited

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshRefinement::_refine_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::FEMSystem::assemble_qoi(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DofMap::build_sparsity(), libMesh::System::calculate_norm(), libMesh::VTKIO::cells_to_vtk(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::EquationSystems::get_solution(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::System::local_dof_indices(), libMesh::DofMap::local_variable_indices(), libMesh::DofMap::max_constraint_error(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshTools::n_active_local_levels(), libMesh::PointLocatorTree::perform_fuzzy_linear_search(), libMesh::PointLocatorTree::perform_linear_search(), libMesh::ErrorVector::plot_error(), libMesh::FEMSystem::postprocess(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::DofMap::scatter_constraints(), libMesh::HPSingularity::select_refinement(), libMesh::HPCoarsenTest::select_refinement(), libMesh::MeshBase::subdomain_ids(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::Tree< N >::Tree(), libMesh::Nemesis_IO_Helper::write_exodus_initialization_info(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::EnsightIO::write_vector_ascii(), and libMesh::System::zero_variable().

virtual const_element_iterator libMesh::MeshBase::active_local_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_local_elements_end ( )
pure virtualinherited

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshRefinement::_refine_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::FEMSystem::assemble_qoi(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DofMap::build_sparsity(), libMesh::System::calculate_norm(), libMesh::VTKIO::cells_to_vtk(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::EquationSystems::get_solution(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::System::local_dof_indices(), libMesh::DofMap::local_variable_indices(), libMesh::DofMap::max_constraint_error(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshTools::n_active_local_levels(), libMesh::PointLocatorTree::perform_fuzzy_linear_search(), libMesh::PointLocatorTree::perform_linear_search(), libMesh::ErrorVector::plot_error(), libMesh::FEMSystem::postprocess(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::DofMap::scatter_constraints(), libMesh::HPSingularity::select_refinement(), libMesh::HPCoarsenTest::select_refinement(), libMesh::MeshBase::subdomain_ids(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::Tree< N >::Tree(), libMesh::Nemesis_IO_Helper::write_exodus_initialization_info(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::EnsightIO::write_vector_ascii(), and libMesh::System::zero_variable().

virtual const_element_iterator libMesh::MeshBase::active_local_elements_end ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::active_nodes_begin ( )
pure virtualinherited

Iterate over only the active nodes in the Mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_node_iterator libMesh::MeshBase::active_nodes_begin ( ) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::active_nodes_end ( )
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::active_nodes_end ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_not_local_elements_begin ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_not_local_elements_end ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_pid_elements_begin ( processor_id_type  proc_id) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_pid_elements_end ( processor_id_type  proc_id) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_semilocal_elements_begin ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_semilocal_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_semilocal_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_semilocal_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_subdomain_elements_end ( subdomain_id_type  subdomain_id)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_subdomain_elements_end ( subdomain_id_type  subdomain_id) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_subdomain_set_elements_begin ( std::set< subdomain_id_type ss)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_subdomain_set_elements_begin ( std::set< subdomain_id_type ss) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_subdomain_set_elements_end ( std::set< subdomain_id_type ss)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_subdomain_set_elements_end ( std::set< subdomain_id_type ss) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_type_elements_begin ( ElemType  type)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_type_elements_begin ( ElemType  type) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_type_elements_end ( ElemType  type)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_type_elements_end ( ElemType  type) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_unpartitioned_elements_begin ( )
pure virtualinherited

Iterate over active unpartitioned elements in the Mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_element_iterator libMesh::MeshBase::active_unpartitioned_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::active_unpartitioned_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::active_unpartitioned_elements_end ( ) const
pure virtualinherited
virtual Elem* libMesh::MeshBase::add_elem ( Elem e)
pure virtualinherited

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::MeshRefinement::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::Generation::build_sphere(), copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), create_submesh(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::mesh_inserter_iterator< T >::operator=(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshBase::query_elem(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), and libMesh::TetGenMeshInterface::triangulate_pointset().

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

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

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

765  { _ghosting_functors.insert(&ghosting_functor); }
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1399
virtual Node* libMesh::MeshBase::add_node ( Node n)
pure virtualinherited

Add Node n to the end of the vertex array.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual Node* libMesh::MeshBase::add_point ( const Point p,
const dof_id_type  id = DofObject::invalid_id,
const processor_id_type  proc_id = DofObject::invalid_processor_id 
)
pure virtualinherited

Add a new Node at Point p to the end of the vertex array, with processor_id procid. Use DofObject::invalid_processor_id (default) to add a node to all processors, or this->processor_id() to add a node to the local processor only. If adding a node locally, passing an id other than DofObject::invalid_id will set that specific node id. Only do this in parallel if you are manually keeping ids consistent.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::MeshRefinement::add_node(), all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::Generation::build_sphere(), copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), create_submesh(), libMesh::UNVIO::nodes_in(), libMesh::mesh_inserter_iterator< T >::operator=(), libMesh::MeshBase::query_elem(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::AbaqusIO::read_nodes(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::BoundaryInfo::sync(), libMesh::TriangleInterface::triangulate(), and libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

void libMesh::UnstructuredMesh::all_first_order ( )
virtual

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

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

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

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

Implements libMesh::MeshBase.

Definition at line 303 of file mesh_modification.C.

References libMesh::MeshBase::_is_prepared, libMesh::Elem::add_child(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::MeshBase::delete_node(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::libmesh_assert(), libMesh::MeshBase::max_node_id(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::remote_elem, libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::Elem::replace_child(), libMesh::DofObject::set_id(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_node(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_parent(), libMesh::Elem::set_refinement_flag(), libMesh::DofObject::set_unique_id(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), and libMesh::Elem::which_child_am_i().

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

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 transfered to the second-order element. The old boundary conditions will be removed from the BoundaryInfo data structure by insert_elem.

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

Implements libMesh::MeshBase.

Definition at line 448 of file mesh_modification.C.

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

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

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

Gathers all elements and nodes of the mesh onto every processor

Reimplemented in libMesh::DistributedMesh.

Definition at line 159 of file mesh_base.h.

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

159 {}
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 736 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

Referenced by copy_nodes_and_elements().

bool _allow_remote_element_removal
Definition: mesh_base.h:1363
bool libMesh::MeshBase::allow_remote_element_removal ( ) const
inlineinherited

Definition at line 737 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

Referenced by copy_nodes_and_elements().

bool _allow_remote_element_removal
Definition: mesh_base.h:1363
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, particulary when using a distributed mesh.

Definition at line 727 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

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

bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1355
bool libMesh::MeshBase::allow_renumbering ( ) const
inlineinherited
virtual element_iterator libMesh::MeshBase::ancestor_elements_begin ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::ancestor_elements_begin ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::ancestor_elements_end ( ) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::bid_nodes_begin ( boundary_id_type  bndry_id)
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_node_iterator libMesh::MeshBase::bid_nodes_begin ( boundary_id_type  bndry_id) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::bid_nodes_end ( boundary_id_type  bndry_id)
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::bid_nodes_end ( boundary_id_type  bndry_id) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::bnd_nodes_begin ( )
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_node_iterator libMesh::MeshBase::bnd_nodes_begin ( ) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::bnd_nodes_end ( )
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::bnd_nodes_end ( ) const
pure virtualinherited
void libMesh::MeshBase::cache_elem_dims ( )
inherited

Search the mesh and cache the different dimenions 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 607 of file mesh_base.C.

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

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

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

Deletes all the data that are currently stored.

Reimplemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Definition at line 282 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_n_parts, libMesh::BoundaryInfo::clear(), libMesh::MeshBase::clear_point_locator(), and libMesh::MeshBase::get_boundary_info().

Referenced by libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_sphere(), libMesh::ReplicatedMesh::clear(), libMesh::DistributedMesh::clear(), libMesh::TriangleWrapper::copy_tri_to_mesh(), create_submesh(), libMesh::MeshBase::get_boundary_info(), libMesh::AbaqusIO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::BoundaryInfo::sync(), libMesh::TriangleInterface::triangulate(), and libMesh::MeshBase::~MeshBase().

283 {
284  // Reset the number of partitions
285  _n_parts = 1;
286 
287  // Reset the _is_prepared flag
288  _is_prepared = false;
289 
290  // Clear boundary information
291  this->get_boundary_info().clear();
292 
293  // Clear element dimensions
294  _elem_dims.clear();
295 
296  // Clear our point locator.
297  this->clear_point_locator();
298 }
const BoundaryInfo & get_boundary_info() const
Definition: mesh_base.h:114
unsigned int _n_parts
Definition: mesh_base.h:1308
void clear_point_locator()
Definition: mesh_base.C:550
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1377
void libMesh::MeshBase::clear_point_locator ( )
inherited
virtual UniquePtr<MeshBase> libMesh::MeshBase::clone ( ) const
pure virtualinherited
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DistributedVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TopologyMap::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::DistributedVector< T >::max(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::DistributedVector< T >::min(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::DistributedVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

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

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

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

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

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

Definition at line 71 of file unstructured_mesh.C.

References libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_n_parts, libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::Elem::has_children(), libMesh::DofObject::id(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libmesh_nullptr, libMesh::Elem::n_children(), libMesh::MeshBase::n_elem(), libMesh::Elem::n_neighbors(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_neighbor(), libMesh::DofObject::set_unique_id(), libMesh::MeshBase::skip_partitioning(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), and libMesh::Elem::which_child_am_i().

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

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

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

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

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

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

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::MeshBase::node_ptr(), libMesh::Elem::point(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), libMesh::DofObject::set_unique_id(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::DofObject::unique_id().

Referenced by create_pid_mesh().

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

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), contract(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::MeshTools::Modification::flatten(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshBase::query_elem(), libMesh::AbaqusIO::read(), and libMesh::UNVIO::read_implementation().

virtual void libMesh::MeshBase::delete_node ( Node n)
pure virtualinherited

Removes the Node n from the mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by all_first_order(), and libMesh::MeshBase::query_elem().

virtual void libMesh::MeshBase::delete_remote_elements ( )
inlinevirtualinherited

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 172 of file mesh_base.h.

References libMesh::MeshBase::mesh_dimension().

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

172 {}
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 673 of file mesh_base.C.

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

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

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

Definition at line 508 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

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

509  {
510  libmesh_deprecated();
511  return this->elem_ptr(i);
512  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual Elem* libMesh::MeshBase::elem ( const dof_id_type  i)
inlinevirtualinherited
Returns
A writable pointer to the $ i^{th} $ element, which should be present in this processor's subset of the mesh data structure.
Deprecated:
Use the less confusingly-named elem_ptr() instead.

Definition at line 521 of file mesh_base.h.

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

References libMesh::MeshBase::elem_ptr().

485  {
486  return *this->elem_ptr(i);
487  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual element_iterator libMesh::MeshBase::elements_begin ( )
pure virtualinherited

Iterate over all the elements in the Mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::_add_system_to_nodes_and_elems(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::CentroidPartitioner::_do_partition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshRefinement::_refine_elements(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_p_to_h_refinement(), libMesh::VariationalMeshSmoother::adjust_adapt_data(), all_first_order(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::allgather(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::TetGenMeshInterface::check_hull_integrity(), libMesh::MeshRefinement::clean_refinement_flags(), libMesh::MeshRefinement::coarsen_elements(), contract(), copy_nodes_and_elements(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::DofMap::distribute_dofs(), libMesh::MeshTools::elem_types(), libMesh::UNVIO::elements_out(), libMesh::TopologyMap::fill(), find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshTools::get_not_subactive_node_ids(), libMesh::EquationSystems::init(), libMesh::MeshTools::libmesh_assert_connected_nodes(), libMesh::MeshTools::libmesh_assert_equal_n_systems(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::MeshTools::libmesh_assert_old_dof_objects(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshBase::n_sub_elem(), libMesh::MeshTools::paranoid_n_levels(), libMesh::ErrorVector::plot_error(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::AbaqusIO::read(), libMesh::UNVIO::read_implementation(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::EquationSystems::reinit(), libMesh::DofMap::reinit(), libMesh::Partitioner::single_partition(), libMesh::MeshRefinement::switch_h_to_p_refinement(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::Subdivision::tag_boundary_ghosts(), libMesh::MeshTools::total_weight(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::CheckpointIO::write(), and libMesh::UCDIO::write_interior_elems().

virtual const_element_iterator libMesh::MeshBase::elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::elements_end ( )
pure virtualinherited

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::_add_system_to_nodes_and_elems(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::CentroidPartitioner::_do_partition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshRefinement::_refine_elements(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_p_to_h_refinement(), libMesh::VariationalMeshSmoother::adjust_adapt_data(), all_first_order(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::allgather(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::TetGenMeshInterface::check_hull_integrity(), libMesh::MeshRefinement::clean_refinement_flags(), libMesh::MeshRefinement::coarsen_elements(), contract(), copy_nodes_and_elements(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::DofMap::distribute_dofs(), libMesh::MeshTools::elem_types(), libMesh::UNVIO::elements_out(), libMesh::TopologyMap::fill(), find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshTools::get_not_subactive_node_ids(), libMesh::EquationSystems::init(), libMesh::MeshTools::libmesh_assert_connected_nodes(), libMesh::MeshTools::libmesh_assert_equal_n_systems(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::MeshTools::libmesh_assert_old_dof_objects(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshBase::n_sub_elem(), libMesh::MeshTools::paranoid_n_levels(), libMesh::ErrorVector::plot_error(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::AbaqusIO::read(), libMesh::UNVIO::read_implementation(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::EquationSystems::reinit(), libMesh::DofMap::reinit(), libMesh::Partitioner::single_partition(), libMesh::MeshRefinement::switch_h_to_p_refinement(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::Subdivision::tag_boundary_ghosts(), libMesh::MeshTools::total_weight(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::CheckpointIO::write(), and libMesh::UCDIO::write_interior_elems().

virtual const_element_iterator libMesh::MeshBase::elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::evaluable_elements_begin ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_element_iterator libMesh::MeshBase::evaluable_elements_begin ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::evaluable_elements_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::evaluable_elements_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::evaluable_nodes_begin ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_node_iterator libMesh::MeshBase::evaluable_nodes_begin ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::evaluable_nodes_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
)
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::evaluable_nodes_end ( const DofMap dof_map,
unsigned int  var_num = libMesh::invalid_uint 
) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::facelocal_elements_begin ( )
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_element_iterator libMesh::MeshBase::facelocal_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::facelocal_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::facelocal_elements_end ( ) const
pure virtualinherited
void libMesh::UnstructuredMesh::find_neighbors ( const bool  reset_remote_elements = false,
const bool  reset_current_list = true 
)
virtual

Other functions from MeshBase requiring re-definition.

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

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

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

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

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

Implements libMesh::MeshBase.

Definition at line 236 of file unstructured_mesh.C.

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::centroid(), libMesh::Elem::child_ptr(), libMesh::Elem::dim(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::err, libMesh::Elem::has_children(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::Elem::is_ancestor_of(), libMesh::Elem::is_child_on_side(), libMesh::Elem::key(), libMesh::Elem::level(), libMesh::MeshBase::level_elements_begin(), libMesh::MeshBase::level_elements_end(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libmesh_nullptr, libMesh::Elem::n_children(), libMesh::MeshTools::n_levels(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Elem::point(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::remote_elem, libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::Elem::side_ptr(), libMesh::Elem::subactive(), libMesh::TOLERANCE, libMesh::Elem::which_child_am_i(), and libMesh::NameBasedIO::write().

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

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

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::_read_impl(), and libMesh::MeshBase::query_elem().

virtual element_iterator libMesh::MeshBase::flagged_elements_begin ( unsigned char  rflag)
pure virtualinherited

Iterate over all elements with a specified refinement flag.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_element_iterator libMesh::MeshBase::flagged_elements_begin ( unsigned char  rflag) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::flagged_elements_end ( unsigned char  rflag)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::flagged_elements_end ( unsigned char  rflag) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::flagged_pid_elements_begin ( unsigned char  rflag,
processor_id_type  pid 
)
pure virtualinherited

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::query_ghosting_functors(), and libMesh::MeshCommunication::send_coarse_ghosts().

virtual const_element_iterator libMesh::MeshBase::flagged_pid_elements_begin ( unsigned char  rflag,
processor_id_type  pid 
) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::flagged_pid_elements_end ( unsigned char  rflag,
processor_id_type  pid 
)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::flagged_pid_elements_end ( unsigned char  rflag,
processor_id_type  pid 
) const
pure virtualinherited
virtual void libMesh::MeshBase::gather_to_zero ( )
inlinevirtualinherited

Gathers all elements and nodes of the mesh onto processor zero

Reimplemented in libMesh::DistributedMesh.

Definition at line 165 of file mesh_base.h.

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

165 {}
const BoundaryInfo& libMesh::MeshBase::get_boundary_info ( ) const
inlineinherited

The information about boundary ids on the mesh

Definition at line 114 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), all_first_order(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshBase::clear(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), create_submesh(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::UNVIO::groups_in(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::BoundaryProjectSolution::operator()(), libMesh::Parallel::Packing< const Node * >::pack(), libMesh::Parallel::Packing< const Elem * >::pack(), libMesh::Parallel::Packing< const Node * >::packable_size(), libMesh::Parallel::Packing< const Elem * >::packable_size(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_nodesets(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), libMesh::Elem::topological_neighbor(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

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

Writable information about boundary ids on the mesh

Definition at line 119 of file mesh_base.h.

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

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

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

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

565 {
567 }
bool _count_lower_dim_elems_in_point_locator
Definition: mesh_base.h:1328
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 591 of file mesh_base.C.

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

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

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

Definition at line 411 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::n_partitions(), and libMesh::MeshBase::print_info().

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual const_element_iterator libMesh::MeshBase::ghost_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::ghost_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::ghost_elements_end ( ) const
pure virtualinherited
std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_begin ( ) const
inlineinherited
std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_end ( ) const
inlineinherited
virtual Elem* libMesh::MeshBase::insert_elem ( Elem e)
pure virtualinherited

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

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by all_first_order(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), and libMesh::MeshBase::query_elem().

virtual Node* libMesh::MeshBase::insert_node ( Node n)
pure virtualinherited

Insert Node n into the Mesh at a location consistent with n->id(), allocating extra storage if necessary. Will error rather than overwriting an existing Node. Primarily intended for use with the mesh_inserter_iterator, only use if you know what you are doing...

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::mesh_inserter_iterator< T >::operator=(), and libMesh::MeshBase::query_elem().

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

Definition at line 130 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

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

131  { return _is_prepared; }
virtual bool libMesh::MeshBase::is_replicated ( ) const
inlinevirtualinherited
Returns
true if new elements and nodes can and should be created in synchronization on all processors, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 152 of file mesh_base.h.

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

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 137 of file mesh_base.h.

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

138  { return true; }
virtual element_iterator libMesh::MeshBase::level_elements_begin ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::level_elements_begin ( unsigned int  level) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::level_elements_end ( unsigned int  level) const
pure virtualinherited
virtual void libMesh::MeshBase::libmesh_assert_valid_parallel_ids ( ) const
inlinevirtualinherited

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 941 of file mesh_base.h.

References libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::MeshBase::active_local_subdomain_elements_begin(), libMesh::MeshBase::active_local_subdomain_elements_end(), libMesh::MeshBase::active_nodes_begin(), libMesh::MeshBase::active_nodes_end(), libMesh::MeshBase::active_not_local_elements_begin(), libMesh::MeshBase::active_not_local_elements_end(), libMesh::MeshBase::active_pid_elements_begin(), libMesh::MeshBase::active_pid_elements_end(), libMesh::MeshBase::active_semilocal_elements_begin(), libMesh::MeshBase::active_semilocal_elements_end(), libMesh::MeshBase::active_subdomain_elements_begin(), libMesh::MeshBase::active_subdomain_elements_end(), libMesh::MeshBase::active_subdomain_set_elements_begin(), libMesh::MeshBase::active_subdomain_set_elements_end(), libMesh::MeshBase::active_type_elements_begin(), libMesh::MeshBase::active_type_elements_end(), libMesh::MeshBase::active_unpartitioned_elements_begin(), libMesh::MeshBase::active_unpartitioned_elements_end(), libMesh::MeshBase::ancestor_elements_begin(), libMesh::MeshBase::ancestor_elements_end(), libMesh::MeshBase::bid_nodes_begin(), libMesh::MeshBase::bid_nodes_end(), libMesh::MeshBase::bnd_nodes_begin(), libMesh::MeshBase::bnd_nodes_end(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::MeshBase::evaluable_elements_begin(), libMesh::MeshBase::evaluable_elements_end(), libMesh::MeshBase::evaluable_nodes_begin(), libMesh::MeshBase::evaluable_nodes_end(), libMesh::MeshBase::facelocal_elements_begin(), libMesh::MeshBase::facelocal_elements_end(), libMesh::MeshBase::flagged_elements_begin(), libMesh::MeshBase::flagged_elements_end(), libMesh::MeshBase::flagged_pid_elements_begin(), libMesh::MeshBase::flagged_pid_elements_end(), libMesh::MeshBase::get_id_by_name(), libMesh::MeshBase::ghost_elements_begin(), libMesh::MeshBase::ghost_elements_end(), libMesh::invalid_uint, libMesh::MeshBase::level_elements_begin(), libMesh::MeshBase::level_elements_end(), libMesh::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), libMesh::MeshBase::local_level_elements_begin(), libMesh::MeshBase::local_level_elements_end(), libMesh::MeshBase::local_nodes_begin(), libMesh::MeshBase::local_nodes_end(), libMesh::MeshBase::local_not_level_elements_begin(), libMesh::MeshBase::local_not_level_elements_end(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::MeshBase::not_active_elements_begin(), libMesh::MeshBase::not_active_elements_end(), libMesh::MeshBase::not_ancestor_elements_begin(), libMesh::MeshBase::not_ancestor_elements_end(), libMesh::MeshBase::not_level_elements_begin(), libMesh::MeshBase::not_level_elements_end(), libMesh::MeshBase::not_local_elements_begin(), libMesh::MeshBase::not_local_elements_end(), libMesh::MeshBase::not_subactive_elements_begin(), libMesh::MeshBase::not_subactive_elements_end(), libMesh::MeshBase::pid_elements_begin(), libMesh::MeshBase::pid_elements_end(), libMesh::MeshBase::pid_nodes_begin(), libMesh::MeshBase::pid_nodes_end(), libMesh::MeshBase::semilocal_elements_begin(), libMesh::MeshBase::semilocal_elements_end(), libMesh::MeshBase::subactive_elements_begin(), libMesh::MeshBase::subactive_elements_end(), libMesh::MeshBase::subdomain_name(), libMesh::MeshBase::type_elements_begin(), libMesh::MeshBase::type_elements_end(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

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

941 {}
virtual const_element_iterator libMesh::MeshBase::local_elements_begin ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::local_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::local_level_elements_begin ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::local_level_elements_begin ( unsigned int  level) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::local_level_elements_end ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::local_level_elements_end ( unsigned int  level) const
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::local_nodes_begin ( ) const
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::local_nodes_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::local_not_level_elements_begin ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::local_not_level_elements_begin ( unsigned int  level) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::local_not_level_elements_end ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::local_not_level_elements_end ( unsigned int  level) const
pure virtualinherited
unsigned int libMesh::MeshBase::mesh_dimension ( ) const
inherited
Returns
The logical dimension of the mesh; i.e. the manifold dimension of the elements in the mesh. If we ever support multi-dimensional meshes (e.g. hexes and quads in the same mesh) then this will return the largest such dimension.

Definition at line 147 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::HPCoarsenTest::add_projection(), all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshTools::Generation::build_sphere(), libMesh::EquationSystems::build_variable_names(), libMesh::MeshBase::cache_elem_dims(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshTools::Modification::distort(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::LaplaceMeshSmoother::init(), libMesh::PointLocatorTree::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::FEInterface::n_vec_dim(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::GMVIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::HPCoarsenTest::select_refinement(), libMesh::MeshTools::Modification::smooth(), libMesh::DofMap::use_coupled_neighbor_dofs(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UCDIO::write_nodal_data(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), and libMesh::EnsightIO::write_vector_ascii().

148 {
149  if (!_elem_dims.empty())
150  return cast_int<unsigned int>(*_elem_dims.rbegin());
151  return 0;
152 }
std::set< unsigned char > _elem_dims
Definition: mesh_base.h:1377
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 372 of file mesh_base.C.

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

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

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

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

Definition at line 396 of file mesh_base.C.

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

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

397 {
398  dof_id_type ne=0;
399 
400  const_element_iterator el = this->active_elements_begin();
401  const const_element_iterator end = this->active_elements_end();
402 
403  for (; el!=end; ++el)
404  ne += (*el)->n_sub_elem();
405 
406  return ne;
407 }
IterBase * end
virtual element_iterator active_elements_begin()=0
virtual element_iterator active_elements_end()=0
uint8_t dof_id_type
Definition: id_types.h:64
virtual dof_id_type libMesh::MeshBase::n_elem ( ) const
pure virtualinherited
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.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::TetGenMeshInterface::check_hull_integrity(), copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), create_submesh(), libMesh::MeshTools::Modification::distort(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::SFCPartitioner::partition_range(), libMesh::ErrorVector::plot_error(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::MeshTools::Modification::redistribute(), libMesh::MeshBase::set_next_unique_id(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::XdrIO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::UCDIO::write_nodal_data(), and libMesh::XdrIO::write_serialized_connectivity().

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

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

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

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

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

363  { 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:359
processor_id_type processor_id() const
dof_id_type libMesh::MeshBase::n_local_nodes ( ) const
inlineinherited
Returns
The number of nodes on the local processor.

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

263  { 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:346
processor_id_type processor_id() const
virtual dof_id_type libMesh::MeshBase::n_nodes ( ) const
pure virtualinherited
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.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by all_second_order(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::EquationSystems::build_parallel_solution_vector(), copy_nodes_and_elements(), create_submesh(), libMesh::MeshTools::Modification::distort(), libMesh::MeshBase::elem_dimensions(), libMesh::TetGenMeshInterface::fill_pointlist(), libMesh::MeshBase::get_info(), libMesh::TreeNode< N >::insert(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::VariationalMeshSmoother::metr_data_gen(), libMesh::ErrorVector::plot_error(), libMesh::Nemesis_IO::read(), libMesh::AbaqusIO::read_nodes(), libMesh::MeshTools::Modification::redistribute(), libMesh::MeshTools::Modification::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::TreeNode< N >::transform_nodes_to_elements(), libMesh::TriangleInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::XdrIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::UCDIO::write_header(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::GmshIO::write_post(), libMesh::XdrIO::write_serialized_nodes(), libMesh::UCDIO::write_soln(), and libMesh::VariationalMeshSmoother::writegr().

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

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

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

347 {
348  // We're either counting a processor's nodes or unpartitioned
349  // nodes
350  libmesh_assert (proc_id < this->n_processors() ||
352 
353  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
354  this->pid_nodes_end (proc_id)));
355 }
virtual node_iterator pid_nodes_end(processor_id_type proc_id)=0
processor_id_type n_processors() const
libmesh_assert(j)
static const processor_id_type invalid_processor_id
Definition: dof_object.h:345
virtual node_iterator pid_nodes_begin(processor_id_type proc_id)=0
uint8_t dof_id_type
Definition: id_types.h:64
unsigned int libMesh::MeshBase::n_partitions ( ) const
inlineinherited
Returns
The number of partitions which have been defined via a call to either mesh.partition() or by building a Partitioner object and calling partition.
Note
The partitioner object is responsible for setting this value.

Definition at line 811 of file mesh_base.h.

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

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

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

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:722
const Parallel::Communicator & _communicator
dof_id_type libMesh::MeshBase::n_sub_elem ( ) const
inherited
Returns
The number of elements that will be written out in certain I/O formats.

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

Definition at line 381 of file mesh_base.C.

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

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

382 {
383  dof_id_type ne=0;
384 
385  const_element_iterator el = this->elements_begin();
386  const const_element_iterator end = this->elements_end();
387 
388  for (; el!=end; ++el)
389  ne += (*el)->n_sub_elem();
390 
391  return ne;
392 }
IterBase * end
virtual element_iterator elements_begin()=0
virtual element_iterator elements_end()=0
uint8_t dof_id_type
Definition: id_types.h:64
subdomain_id_type libMesh::MeshBase::n_subdomains ( ) const
inherited
Returns
The number of subdomains in the global mesh. Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Definition at line 331 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

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

Definition at line 368 of file mesh_base.h.

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

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

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

Definition at line 268 of file mesh_base.h.

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

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

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

Definition at line 281 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

281 { return _next_unique_id; }
unique_id_type _next_unique_id
Definition: mesh_base.h:1342
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 429 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

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

430  {
431  libmesh_deprecated();
432  return *this->node_ptr(i);
433  }
virtual const Node * node_ptr(const dof_id_type i) const =0
virtual Node& libMesh::MeshBase::node ( const dof_id_type  i)
inlinevirtualinherited
Returns
A reference to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.
Deprecated:
Use the less confusingly-named node_ref() instead.

Definition at line 441 of file mesh_base.h.

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

442  {
443  libmesh_deprecated();
444  return *this->node_ptr(i);
445  }
virtual const Node * node_ptr(const dof_id_type i) const =0
virtual Node* libMesh::MeshBase::node_ptr ( const dof_id_type  i)
pure virtualinherited
Returns
A writable pointer to the $ i^{th} $ node, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

Definition at line 418 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

418  {
419  return *this->node_ptr(i);
420  }
virtual const Node * node_ptr(const dof_id_type i) const =0
virtual node_iterator libMesh::MeshBase::nodes_begin ( )
pure virtualinherited

Iterate over all the nodes in the Mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::_add_system_to_nodes_and_elems(), all_first_order(), libMesh::EquationSystems::allgather(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshBase::cache_elem_dims(), copy_nodes_and_elements(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::DofMap::distribute_dofs(), libMesh::LocationMap< T >::fill(), libMesh::TetGenMeshInterface::fill_pointlist(), libMesh::LocationMap< T >::init(), libMesh::EquationSystems::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DofMap::invalidate_dofs(), libMesh::MeshTools::libmesh_assert_connected_nodes(), libMesh::MeshTools::libmesh_assert_equal_n_systems(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::FEMSystem::mesh_position_set(), libMesh::UNVIO::nodes_out(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshTools::Modification::redistribute(), libMesh::EquationSystems::reinit(), libMesh::DofMap::reinit(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), libMesh::Partitioner::set_node_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::Modification::translate(), libMesh::Tree< N >::Tree(), libMesh::TriangleInterface::triangulate(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodes(), and libMesh::VariationalMeshSmoother::writegr().

virtual const_node_iterator libMesh::MeshBase::nodes_begin ( ) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::nodes_end ( )
pure virtualinherited

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::_add_system_to_nodes_and_elems(), all_first_order(), libMesh::EquationSystems::allgather(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshBase::cache_elem_dims(), copy_nodes_and_elements(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::DofMap::distribute_dofs(), libMesh::LocationMap< T >::fill(), libMesh::TetGenMeshInterface::fill_pointlist(), libMesh::LocationMap< T >::init(), libMesh::EquationSystems::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DofMap::invalidate_dofs(), libMesh::MeshTools::libmesh_assert_connected_nodes(), libMesh::MeshTools::libmesh_assert_equal_n_systems(), libMesh::MeshBase::libmesh_assert_valid_parallel_ids(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::FEMSystem::mesh_position_set(), libMesh::UNVIO::nodes_out(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshTools::Modification::redistribute(), libMesh::EquationSystems::reinit(), libMesh::DofMap::reinit(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), libMesh::Partitioner::set_node_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::Modification::translate(), libMesh::Tree< N >::Tree(), libMesh::TriangleInterface::triangulate(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodes(), and libMesh::VariationalMeshSmoother::writegr().

virtual const_node_iterator libMesh::MeshBase::nodes_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_active_elements_begin ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_active_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_active_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_active_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_ancestor_elements_begin ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_ancestor_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_ancestor_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_ancestor_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_level_elements_begin ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_level_elements_begin ( unsigned int  level) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_level_elements_end ( unsigned int  level)
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_level_elements_end ( unsigned int  level) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_local_elements_begin ( ) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_local_elements_end ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_subactive_elements_begin ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_subactive_elements_begin ( ) const
pure virtualinherited
virtual element_iterator libMesh::MeshBase::not_subactive_elements_end ( )
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::not_subactive_elements_end ( ) const
pure virtualinherited
virtual unique_id_type libMesh::MeshBase::parallel_max_unique_id ( ) const
pure virtualinherited
virtual dof_id_type libMesh::MeshBase::parallel_n_elem ( ) const
pure virtualinherited
Returns
The number of elements in the mesh.

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::Nemesis_IO_Helper::initialize(), libMesh::Nemesis_IO::read(), and libMesh::MeshBase::set_next_unique_id().

virtual dof_id_type libMesh::MeshBase::parallel_n_nodes ( ) const
pure virtualinherited
Returns
The number of nodes in the mesh.

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshBase::elem_dimensions(), libMesh::Nemesis_IO_Helper::initialize(), and libMesh::Nemesis_IO::read().

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

Call the default partitioner (currently metis_partition()).

Definition at line 459 of file mesh_base.C.

References libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::partitioner(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::Partitioner::set_node_processor_ids(), libMesh::MeshBase::skip_partitioning(), and libMesh::MeshBase::update_post_partitioning().

460 {
461  // If we get here and we have unpartitioned elements, we need that
462  // fixed.
463  if (this->n_unpartitioned_elem() > 0)
464  {
465  libmesh_assert (partitioner().get());
466  libmesh_assert (this->is_serial());
467  partitioner()->partition (*this, n_parts);
468  }
469  // NULL partitioner means don't repartition
470  // Non-serial meshes may not be ready for repartitioning here.
471  else if (!skip_partitioning() && partitioner().get())
472  {
473  partitioner()->partition (*this, n_parts);
474  }
475  else
476  {
477  // Adaptive coarsening may have "orphaned" nodes on processors
478  // whose elements no longer share them. We need to check for
479  // and possibly fix that.
481 
482  // Make sure locally cached partition count
483  this->recalculate_n_partitions();
484 
485  // Make sure any other locally cached data is correct
486  this->update_post_partitioning();
487  }
488 }
virtual bool is_serial() const
Definition: mesh_base.h:137
bool skip_partitioning() const
Definition: mesh_base.h:753
static void set_node_processor_ids(MeshBase &mesh)
Definition: partitioner.C:431
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:368
libmesh_assert(j)
unsigned int recalculate_n_partitions()
Definition: mesh_base.C:490
virtual UniquePtr< Partitioner > & partitioner()
Definition: mesh_base.h:109
virtual void update_post_partitioning()
Definition: mesh_base.h:719
void libMesh::MeshBase::partition ( )
inlineinherited

Definition at line 705 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

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

706  { this->partition(this->n_processors()); }
processor_id_type n_processors() const
virtual UniquePtr<Partitioner>& libMesh::MeshBase::partitioner ( )
inlinevirtualinherited
virtual const_element_iterator libMesh::MeshBase::pid_elements_begin ( processor_id_type  proc_id) const
pure virtualinherited
virtual const_element_iterator libMesh::MeshBase::pid_elements_end ( processor_id_type  proc_id) const
pure virtualinherited
virtual node_iterator libMesh::MeshBase::pid_nodes_begin ( processor_id_type  proc_id)
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::pid_nodes_begin ( processor_id_type  proc_id) const
pure virtualinherited
virtual const_node_iterator libMesh::MeshBase::pid_nodes_end ( processor_id_type  proc_id) const
pure virtualinherited
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 513 of file mesh_base.C.

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

514 {
515  libmesh_deprecated();
516 
517  if (_point_locator.get() == libmesh_nullptr)
518  {
519  // PointLocator construction may not be safe within threads
521 
522  _point_locator.reset (PointLocatorBase::build(TREE_ELEMENTS, *this).release());
523  }
524 
525  return *_point_locator;
526 }
UniquePtr< PointLocatorBase > _point_locator
Definition: mesh_base.h:1322
const class libmesh_nullptr_t libmesh_nullptr
bool in_threads
Definition: threads.C:31
libmesh_assert(j)
static UniquePtr< PointLocatorBase > build(PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=libmesh_nullptr)
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 173 of file mesh_base.C.

References libMesh::MeshBase::_allow_remote_element_removal, 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::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::GhostingFunctor::mesh_reinit(), libMesh::MeshBase::partition(), libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::MeshBase::update_parallel_id_counts(), and libMesh::Parallel::verify().

Referenced by all_first_order(), all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshRefinement::coarsen_elements(), copy_nodes_and_elements(), create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::MeshBase::query_elem(), libMesh::GMVIO::read(), 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().

174 {
175  parallel_object_only();
176 
177  libmesh_assert(this->comm().verify(this->is_serial()));
178 
179  // A distributed mesh may have processors with no elements (or
180  // processors with no elements of higher dimension, if we ever
181  // support mixed-dimension meshes), but we want consistent
182  // mesh_dimension anyways.
183  //
184  // cache_elem_dims() should get the elem_dimensions() and
185  // mesh_dimension() correct later, and we don't need it earlier.
186 
187 
188  // Renumber the nodes and elements so that they in contiguous
189  // blocks. By default, _skip_renumber_nodes_and_elements is false.
190  //
191  // We may currently change that by passing
192  // skip_renumber_nodes_and_elements==true to this function, but we
193  // should use the allow_renumbering() accessor instead.
194  //
195  // Instances where you if prepare_for_use() should not renumber the nodes
196  // and elements include reading in e.g. an xda/r or gmv file. In
197  // this case, the ordering of the nodes may depend on an accompanying
198  // solution, and the node ordering cannot be changed.
199 
200  if (skip_renumber_nodes_and_elements)
201  {
202  libmesh_deprecated();
203  this->allow_renumbering(false);
204  }
205 
206  // Mesh modification operations might not leave us with consistent
207  // id counts, but our partitioner might need that consistency.
210  else
212 
213  // Let all the elements find their neighbors
214  if (!skip_find_neighbors)
215  this->find_neighbors();
216 
217  // The user may have set boundary conditions. We require that the
218  // boundary conditions were set consistently. Because we examine
219  // neighbors when evaluating non-raw boundary condition IDs, this
220  // assert is only valid when our neighbor links are in place.
221 #ifdef DEBUG
223 #endif
224 
225  // Search the mesh for all the dimensions of the elements
226  // and cache them.
227  this->cache_elem_dims();
228 
229  // Search the mesh for elements that have a neighboring element
230  // of dim+1 and set that element as the interior parent
231  this->detect_interior_parents();
232 
233  // Fix up node unique ids in case mesh generation code didn't take
234  // exceptional care to do so.
235  // MeshCommunication().make_node_unique_ids_parallel_consistent(*this);
236 
237  // We're going to still require that mesh generation code gets
238  // element unique ids consistent.
239 #if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
241 #endif
242 
243  // Reset our PointLocator. Any old locator is invalidated any time
244  // the elements in the underlying elements in the mesh have changed,
245  // so we clear it here.
246  this->clear_point_locator();
247 
248  // Allow our GhostingFunctor objects to reinit if necessary.
249  // Do this before partitioning and redistributing, and before
250  // deleting remote elements.
251  std::set<GhostingFunctor *>::iterator gf_it = this->ghosting_functors_begin();
252  const std::set<GhostingFunctor *>::iterator gf_end = this->ghosting_functors_end();
253  for (; gf_it != gf_end; ++gf_it)
254  {
255  GhostingFunctor * gf = *gf_it;
256  libmesh_assert(gf);
257  gf->mesh_reinit();
258  }
259 
260  // Partition the mesh.
261  this->partition();
262 
263  // If we're using DistributedMesh, we'll probably want it
264  // parallelized.
266  this->delete_remote_elements();
267 
270 
271  // The mesh is now prepared for use.
272  _is_prepared = true;
273 
274 #if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
277 #endif
278 }
bool _skip_renumber_nodes_and_elements
Definition: mesh_base.h:1355
virtual bool is_serial() const
Definition: mesh_base.h:137
void detect_interior_parents()
Definition: mesh_base.C:673
bool _allow_remote_element_removal
Definition: mesh_base.h:1363
libmesh_assert(j)
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
Definition: mesh_base.h:782
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:550
void libmesh_assert_valid_boundary_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1255
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Definition: mesh_base.h:776
bool verify(const T &r, const Communicator &comm=Communicator_World)
const Parallel::Communicator & comm() const
bool allow_renumbering() const
Definition: mesh_base.h:728
virtual void delete_remote_elements()
Definition: mesh_base.h:172
void cache_elem_dims()
Definition: mesh_base.C:607
void libmesh_assert_valid_unique_ids(const MeshBase &mesh)
Definition: mesh_tools.C:1405
virtual void renumber_nodes_and_elements()=0
void libMesh::MeshBase::print_info ( std::ostream &  os = libMesh::out) const
inherited

Prints relevant information about the mesh.

Definition at line 445 of file mesh_base.C.

References libMesh::MeshBase::get_info().

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

446 {
447  os << this->get_info()
448  << std::endl;
449 }
std::string get_info() const
Definition: mesh_base.C:411
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 99 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::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), 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::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), 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::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), 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::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), 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::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::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), 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::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::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::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::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:720
virtual const Elem* libMesh::MeshBase::query_elem ( const dof_id_type  i) const
inlinevirtualinherited
Returns
A pointer to the $ i^{th} $ element, or NULL 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 545 of file mesh_base.h.

References libMesh::MeshBase::query_elem_ptr().

546  {
547  libmesh_deprecated();
548  return this->query_elem_ptr(i);
549  }
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0
virtual Elem* libMesh::MeshBase::query_elem_ptr ( const dof_id_type  i)
pure virtualinherited
Returns
A writable pointer to the $ i^{th} $ element, or NULL if no such element exists in this processor's mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

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

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

629 {
630  // Set the skip_renumber_nodes_and_elements flag on all processors
631  // if necessary.
632  // This ensures that renumber_nodes_and_elements is *not* called
633  // during prepare_for_use() for certain types of mesh files.
634  // This is required in cases where there is an associated solution
635  // file which expects a certain ordering of the nodes.
636  if (name.rfind(".gmv") + 4 == name.size())
637  this->allow_renumbering(false);
638 
639  NameBasedIO(*this).read(name);
640 
641  if (skip_renumber_nodes_and_elements)
642  {
643  // Use MeshBase::allow_renumbering() yourself instead.
644  libmesh_deprecated();
645  this->allow_renumbering(false);
646  }
647 
648  // Done reading the mesh. Now prepare it for use.
649  this->prepare_for_use(/*skip_renumber (deprecated)*/ false,
650  skip_find_neighbors);
651 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
void prepare_for_use(const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false)
Definition: mesh_base.C:173
bool allow_renumbering() const
Definition: mesh_base.h:728
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 490 of file mesh_base.C.

References libMesh::MeshBase::_n_parts, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::ParallelObject::comm(), end, std::max(), and libMesh::Parallel::Communicator::max().

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

491 {
492  // This requires an inspection on every processor
493  parallel_object_only();
494 
495  const_element_iterator el = this->active_local_elements_begin();
496  const_element_iterator end = this->active_local_elements_end();
497 
498  unsigned int max_proc_id=0;
499 
500  for (; el!=end; ++el)
501  max_proc_id = std::max(max_proc_id, static_cast<unsigned int>((*el)->processor_id()));
502 
503  // The number of partitions is one more than the max processor ID.
504  _n_parts = max_proc_id+1;
505 
506  this->comm().max(_n_parts);
507 
508  return _n_parts;
509 }
IterBase * end
long double max(long double a, double b)
unsigned int _n_parts
Definition: mesh_base.h:1308
virtual element_iterator active_local_elements_begin()=0
const Parallel::Communicator & comm() const
virtual element_iterator active_local_elements_end()=0
virtual void libMesh::MeshBase::redistribute ( )
inlinevirtualinherited

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 713 of file mesh_base.h.

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

713 {}
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 302 of file mesh_base.C.

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

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

303 {
304  // We should only be trying to remove ghosting functors we actually
305  // have
306  libmesh_assert(_ghosting_functors.count(&ghosting_functor));
307  _ghosting_functors.erase(&ghosting_functor);
308 }
libmesh_assert(j)
std::set< GhostingFunctor * > _ghosting_functors
Definition: mesh_base.h:1399
virtual void libMesh::MeshBase::renumber_elem ( dof_id_type  old_id,
dof_id_type  new_id 
)
pure virtualinherited

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.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

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

virtual void libMesh::MeshBase::renumber_node ( dof_id_type  old_id,
dof_id_type  new_id 
)
pure virtualinherited

Changes the id of node old_id, both by changing node(old_id)->id() and by moving node(o