libMesh
Public Types | Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | List of all members
libMesh::ParallelMesh Class Referenceabstract

#include <parallel_mesh.h>

Inheritance diagram for libMesh::ParallelMesh:
[legend]

Public Types

template<typename Obj >
using dofobject_container = mapvector< Obj *, dof_id_type >
 
using dofobject_container = chunked_mapvector< Obj *, dof_id_type, LIBMESH_MAPVECTOR_CHUNK_SIZE >
 
typedef std::set< elemset_id_typeelemset_type
 Typedef for the "set" container used to store elemset ids. More...
 
typedef Predicates::multi_predicate Predicate
 We need an empty, generic class to act as a predicate for this and derived mesh classes. More...
 
typedef std::vector< std::pair< std::pair< const Elem *, unsigned int >, Real > > constraint_rows_mapped_type
 
typedef std::map< const Node *, constraint_rows_mapped_typeconstraint_rows_type
 

Public Member Functions

 ParallelMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
 
 ParallelMesh (const UnstructuredMesh &other_mesh)
 
virtual std::unique_ptr< MeshBaseclone () const override
 Virtual copy-constructor, creates a copy of this mesh. More...
 
 ~ParallelMesh ()=default
 
virtual MeshBaseassign (MeshBase &&other_mesh) override
 Shim to call the move assignment operator for this class. More...
 
virtual bool subclass_locally_equals (const MeshBase &other_mesh) const override
 Shim to allow operator == (&) to behave like a virtual function without having to be one. More...
 
virtual void clear () override
 Clear all internal data. More...
 
virtual void clear_elems () override
 Clear internal Elem data. More...
 
virtual void redistribute () override
 Redistribute elements between processors. More...
 
virtual void update_post_partitioning () override
 Recalculate cached data after elements and nodes have been repartitioned. More...
 
virtual bool is_serial () const override final
 
virtual bool is_serial_on_zero () const override final
 
virtual void set_distributed () override final
 Asserts that not all elements and nodes of the mesh necessarily exist on the current processor. More...
 
virtual bool is_replicated () const override final
 
template<typename T >
void libmesh_assert_valid_parallel_object_ids (const dofobject_container< T > &) const
 Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container. More...
 
virtual void libmesh_assert_valid_parallel_ids () const override
 Verify id and processor_id consistency of our elements and nodes containers. More...
 
void libmesh_assert_valid_parallel_p_levels () const
 Verify p_level consistency of our elements containers. More...
 
void libmesh_assert_valid_parallel_flags () const
 Verify refinement_flag and p_refinement_flag consistency of our elements containers. More...
 
template<typename T >
dof_id_type renumber_dof_objects (dofobject_container< T > &)
 Renumber a parallel objects container. More...
 
virtual void renumber_nodes_and_elements () override
 Remove nullptr elements from arrays. More...
 
virtual void allgather () override
 Gathers all elements and nodes of the mesh onto every processor. More...
 
virtual void gather_to_zero () override
 Gathers all elements and nodes of the mesh onto processor zero. More...
 
virtual void delete_remote_elements () override
 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. More...
 
virtual void add_extra_ghost_elem (Elem *e)
 Inserts the element and adds it to a list of elements that should not get deleted or have their descendants deleted by delete_remote_elements. More...
 
virtual void clear_extra_ghost_elems ()
 Clears extra ghost elements. More...
 
virtual void clear_extra_ghost_elems (const std::set< Elem *> &extra_ghost_elems)
 Clears specified extra ghost elements. More...
 
const std::set< Elem * > & extra_ghost_elems () const
 Const accessor to the ghosted elements. More...
 
virtual dof_id_type n_nodes () const override final
 
virtual dof_id_type max_node_id () const override final
 
virtual void reserve_nodes (const dof_id_type) override final
 Reserves space for a known number of nodes. More...
 
virtual dof_id_type n_elem () const override final
 
virtual dof_id_type n_active_elem () const override final
 
virtual dof_id_type max_elem_id () const override final
 
virtual void reserve_elem (const dof_id_type) override final
 Reserves space for a known number of elements. More...
 
virtual void update_parallel_id_counts () override
 Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors. More...
 
virtual dof_id_type parallel_n_nodes () const override
 
dof_id_type parallel_max_node_id () const
 
virtual dof_id_type parallel_n_elem () const override
 
dof_id_type parallel_max_elem_id () const
 
virtual unique_id_type parallel_max_unique_id () const override
 
virtual void set_next_unique_id (unique_id_type id) override
 Sets the next available unique id to be used. More...
 
virtual const Pointpoint (const dof_id_type i) const override final
 
virtual const Nodenode_ptr (const dof_id_type i) const override final
 
virtual Nodenode_ptr (const dof_id_type i) override final
 
virtual const Nodequery_node_ptr (const dof_id_type i) const override final
 
virtual Nodequery_node_ptr (const dof_id_type i) override final
 
virtual const Elemelem_ptr (const dof_id_type i) const override final
 
virtual Elemelem_ptr (const dof_id_type i) override final
 
virtual const Elemquery_elem_ptr (const dof_id_type i) const override final
 
virtual Elemquery_elem_ptr (const dof_id_type i) override final
 
virtual Nodeadd_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id) override final
 functions for adding /deleting nodes elements. More...
 
virtual Nodeadd_node (Node *n) override final
 Add Node n to the end of the vertex array. More...
 
virtual Nodeadd_node (std::unique_ptr< Node > n) override final
 Version of add_node() taking a std::unique_ptr by value. More...
 
virtual Nodeinsert_node (Node *n) override final
 These methods are deprecated. More...
 
virtual Nodeinsert_node (std::unique_ptr< Node > n) override final
 This method is deprecated. More...
 
virtual void own_node (Node &n) override final
 Takes ownership of node n on this partition of a distributed mesh, by setting n.processor_id() to this->processor_id(), as well as changing n.id() and moving it in the mesh's internal container to give it a new authoritative id. More...
 
virtual void delete_node (Node *n) override final
 Removes the Node n from the mesh. More...
 
virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) override final
 Changes the id of node old_id, both by changing node(old_id)->id() and by moving node(old_id) in the mesh's internal container. More...
 
virtual Elemadd_elem (Elem *e) override final
 Add elem e to the end of the element array. More...
 
virtual Elemadd_elem (std::unique_ptr< Elem > e) override final
 Version of add_elem() taking a std::unique_ptr by value. More...
 
virtual Eleminsert_elem (Elem *e) override final
 Insert elem e to the element array, preserving its id and replacing/deleting any existing element with the same id. More...
 
virtual Eleminsert_elem (std::unique_ptr< Elem > e) override final
 Version of insert_elem() taking a std::unique_ptr by value. More...
 
virtual void delete_elem (Elem *e) override final
 Removes element e from the mesh. More...
 
virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) override final
 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. More...
 
virtual void fix_broken_node_and_element_numbering () override
 There is no reason for a user to ever call this function. More...
 
 DECLARE_ELEM_ITERATORS (,,)
 Elem and Node iterator accessor functions. More...
 
 DECLARE_ELEM_ITERATORS (active_,,)
 
 DECLARE_ELEM_ITERATORS (ancestor_,,) DECLARE_ELEM_ITERATORS(subactive_
 
 DECLARE_ELEM_ITERATORS (local_,,) DECLARE_ELEM_ITERATORS(unpartitioned_
 
 DECLARE_ELEM_ITERATORS (facelocal_,,) DECLARE_ELEM_ITERATORS(level_
 
unsigned int level DECLARE_ELEM_ITERATORS (pid_, processor_id_type pid, pid) DECLARE_ELEM_ITERATORS(type_
 
unsigned int level ElemType type DECLARE_ELEM_ITERATORS (active_subdomain_, subdomain_id_type sid, sid) DECLARE_ELEM_ITERATORS(active_subdomain_set_
 
 DECLARE_ELEM_ITERATORS (not_active_,,)
 
 DECLARE_ELEM_ITERATORS (not_ancestor_,,)
 
 DECLARE_ELEM_ITERATORS (not_subactive_,,)
 
 DECLARE_ELEM_ITERATORS (not_local_,,)
 
 DECLARE_ELEM_ITERATORS (not_level_, unsigned int level, level) DECLARE_ELEM_ITERATORS(active_local_
 
 DECLARE_ELEM_ITERATORS (active_not_local_,,) DECLARE_ELEM_ITERATORS(active_unpartitioned_
 
 DECLARE_ELEM_ITERATORS (active_type_, ElemType type, type) DECLARE_ELEM_ITERATORS(active_pid_
 
processor_id_type pid DECLARE_ELEM_ITERATORS (local_level_, unsigned int level, level) DECLARE_ELEM_ITERATORS(local_not_level_
 
processor_id_type pid unsigned int level DECLARE_ELEM_ITERATORS (active_local_subdomain_, subdomain_id_type sid, sid) DECLARE_ELEM_ITERATORS(active_local_subdomain_set_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss DECLARE_ELEM_ITERATORS (semilocal_,,) DECLARE_ELEM_ITERATORS(ghost_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss DECLARE_ELEM_ITERATORS (active_semilocal_,,) DECLARE_ELEM_ITERATORS(evaluable_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_ELEM_ITERATORS (multi_evaluable_, std::vector< const DofMap *> dof_maps, dof_maps) DECLARE_ELEM_ITERATORS(flagged_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag DECLARE_ELEM_ITERATORS (flagged_pid_, unsigned char rflag LIBMESH_COMMA processor_id_type pid, rflag LIBMESH_COMMA pid) DECLARE_NODE_ITERATORS(
 
unsigned int level ElemType type std::set< subdomain_id_type > virtual ss SimpleRange< element_iteratoractive_subdomain_elements_ptr_range (subdomain_id_type sid) override final
 
virtual SimpleRange< const_element_iteratoractive_subdomain_elements_ptr_range (subdomain_id_type sid) const override final
 
virtual SimpleRange< element_iteratoractive_local_subdomain_elements_ptr_range (subdomain_id_type sid) override final
 
virtual SimpleRange< const_element_iteratoractive_local_subdomain_elements_ptr_range (subdomain_id_type sid) const override final
 
virtual SimpleRange< element_iteratoractive_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) override final
 
virtual SimpleRange< const_element_iteratoractive_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) const override final
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag DECLARE_NODE_ITERATORS (active_,,) DECLARE_NODE_ITERATORS(local_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag DECLARE_NODE_ITERATORS (bnd_,,) DECLARE_NODE_ITERATORS(pid_
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid DECLARE_NODE_ITERATORS (bid_, boundary_id_type bid, bid) DECLARE_NODE_ITERATORS(evaluable_
 
virtual void read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) override
 Reads the file specified by name. More...
 
virtual void write (const std::string &name) override
 Write the file specified by name. More...
 
void write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names)
 Write to the file specified by name. More...
 
virtual void all_first_order () override
 Converts a mesh with higher-order elements into a mesh with linear elements. More...
 
virtual void all_second_order_range (const SimpleRange< element_iterator > &range, const bool full_ordered=true) override
 Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements. More...
 
virtual void all_complete_order_range (const SimpleRange< element_iterator > &range) override
 Converts a (conforming, non-refined) mesh with linear elements into a mesh with "complete" order elements, i.e. More...
 
void 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. More...
 
void create_submesh (UnstructuredMesh &new_mesh, const 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. More...
 
std::size_t stitch_meshes (const MeshBase &other_mesh, boundary_id_type this_mesh_boundary, boundary_id_type other_mesh_boundary, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false, bool merge_boundary_nodes_all_or_nothing=false, bool remap_subdomain_ids=false)
 Stitch other_mesh to this mesh so that this mesh is the union of the two meshes. More...
 
std::size_t stitch_surfaces (boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false, bool merge_boundary_nodes_all_or_nothing=false)
 Similar to stitch_meshes, except that we stitch two adjacent surfaces within this mesh. More...
 
virtual void copy_nodes_and_elements (const MeshBase &other_mesh, const bool skip_find_neighbors=false, dof_id_type element_id_offset=0, dof_id_type node_id_offset=0, unique_id_type unique_id_offset=0, std::unordered_map< subdomain_id_type, subdomain_id_type > *id_remapping=nullptr)
 Deep copy of nodes and elements from another mesh object (used by subclass copy constructors and by mesh merging operations) More...
 
virtual void move_nodes_and_elements (MeshBase &&other_mesh)=0
 Move node and elements from other_mesh to this mesh. More...
 
virtual void find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) override
 Other functions from MeshBase requiring re-definition. More...
 
virtual bool contract () override
 Delete subactive (i.e. More...
 
bool operator== (const MeshBase &other_mesh) const
 This tests for exactly-equal data in all the senses that a mathematician would care about (element connectivity, nodal coordinates), but in the senses a programmer would care about it allows for non-equal equivalence in some ways (we accept different Elem/Node addresses in memory) but not others (we do not accept different subclass types, nor even different Elem/Node ids). More...
 
bool operator!= (const MeshBase &other_mesh) const
 
bool locally_equals (const MeshBase &other_mesh) const
 This behaves the same as operator==, but only for the local and ghosted aspects of the mesh; i.e. More...
 
virtual std::unique_ptr< Partitioner > & partitioner ()
 A partitioner to use at each prepare_for_use() More...
 
const BoundaryInfoget_boundary_info () const
 The information about boundary ids on the mesh. More...
 
BoundaryInfoget_boundary_info ()
 Writable information about boundary ids on the mesh. More...
 
bool is_prepared () const
 
void set_isnt_prepared ()
 Tells this we have done some operation where we should no longer consider ourself prepared. More...
 
void reinit_ghosting_functors ()
 Loops over ghosting functors and calls mesh_reinit() More...
 
unsigned int mesh_dimension () const
 
void set_mesh_dimension (unsigned char d)
 Resets the logical dimension of the mesh. More...
 
const std::set< unsigned char > & elem_dimensions () const
 
void set_elem_dimensions (std::set< unsigned char > elem_dims)
 Most of the time you should not need to call this, as the element dimensions will be set automatically by a call to cache_elem_data(), therefore only call this if you know what you're doing. More...
 
void add_elemset_code (dof_id_type code, MeshBase::elemset_type id_set)
 Tabulate a user-defined "code" for elements which belong to the element sets specified in id_set. More...
 
unsigned int n_elemsets () const
 Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set. More...
 
void get_elemsets (dof_id_type elemset_code, MeshBase::elemset_type &id_set_to_fill) const
 Look up the element sets for a given elemset code and vice-versa. More...
 
dof_id_type get_elemset_code (const MeshBase::elemset_type &id_set) const
 
std::vector< dof_id_typeget_elemset_codes () const
 Return a vector of all elemset codes defined on the mesh. More...
 
void change_elemset_code (dof_id_type old_code, dof_id_type new_code)
 Replace elemset code "old_code" with "new_code". More...
 
void change_elemset_id (elemset_id_type old_id, elemset_id_type new_id)
 Replace elemset id "old_id" with "new_id". More...
 
unsigned int spatial_dimension () const
 
void set_spatial_dimension (unsigned char d)
 Sets the "spatial dimension" of the Mesh. More...
 
dof_id_type n_nodes_on_proc (const processor_id_type proc) const
 
dof_id_type n_local_nodes () const
 
dof_id_type n_unpartitioned_nodes () const
 
unique_id_type next_unique_id ()
 
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
 Same as n_sub_elem(), but only counts active elements. More...
 
virtual const Nodenode_ref (const dof_id_type i) const
 
virtual Nodenode_ref (const dof_id_type i)
 
virtual const Elemelem_ref (const dof_id_type i) const
 
virtual Elemelem_ref (const dof_id_type i)
 
ElemMappingType default_mapping_type () const
 Returns the default master space to physical space mapping basis functions to be used on newly added elements. More...
 
void set_default_mapping_type (const ElemMappingType type)
 Set the default master space to physical space mapping basis functions to be used on newly added elements. More...
 
unsigned char default_mapping_data () const
 Returns any default data value used by the master space to physical space mapping. More...
 
void set_default_mapping_data (const unsigned char data)
 Set the default master space to physical space mapping basis functions to be used on newly added elements. More...
 
void remove_orphaned_nodes ()
 Removes any orphaned nodes, nodes not connected to any elements. More...
 
unsigned int add_elem_integer (std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
 Register an integer datum (of type dof_id_type) to be added to each element in the mesh. More...
 
std::vector< unsigned intadd_elem_integers (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
 Register integer data (of type dof_id_type) to be added to each element in the mesh, one string name for each new integer. More...
 
unsigned int get_elem_integer_index (std::string_view name) const
 
bool has_elem_integer (std::string_view name) const
 
const std::string & get_elem_integer_name (unsigned int i) const
 
unsigned int n_elem_integers () const
 
template<typename T >
unsigned int add_elem_datum (const std::string &name, bool allocate_data=true, const T *default_value=nullptr)
 Register a datum (of type T) to be added to each element in the mesh. More...
 
template<typename T >
std::vector< unsigned intadd_elem_data (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< T > *default_values=nullptr)
 Register data (of type T) to be added to each element in the mesh. More...
 
unsigned int add_node_integer (std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
 Register an integer datum (of type dof_id_type) to be added to each node in the mesh. More...
 
std::vector< unsigned intadd_node_integers (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
 Register integer data (of type dof_id_type) to be added to each node in the mesh. More...
 
unsigned int get_node_integer_index (std::string_view name) const
 
bool has_node_integer (std::string_view name) const
 
const std::string & get_node_integer_name (unsigned int i) const
 
unsigned int n_node_integers () const
 
template<typename T >
unsigned int add_node_datum (const std::string &name, bool allocate_data=true, const T *default_value=nullptr)
 Register a datum (of type T) to be added to each node in the mesh. More...
 
template<typename T >
std::vector< unsigned intadd_node_data (const std::vector< std::string > &name, bool allocate_data=true, const std::vector< T > *default_values=nullptr)
 Register data (of type T) to be added to each node in the mesh. More...
 
void prepare_for_use (const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
 Prepare a newly ecreated (or read) mesh for use. More...
 
void prepare_for_use (const bool skip_renumber_nodes_and_elements)
 
void prepare_for_use ()
 
virtual void partition (const unsigned int n_parts)
 Call the default partitioner (currently metis_partition()). More...
 
void partition ()
 
void allow_renumbering (bool allow)
 If false is passed in then this mesh will no longer be renumbered when being prepared for use. More...
 
bool allow_renumbering () const
 
void allow_find_neighbors (bool allow)
 If false is passed then this mesh will no longer work to find element neighbors when being prepared for use. More...
 
bool allow_find_neighbors () const
 
void allow_remote_element_removal (bool allow)
 If false is passed in then this mesh will no longer have remote elements deleted when being prepared for use; i.e. More...
 
bool allow_remote_element_removal () const
 
void skip_noncritical_partitioning (bool skip)
 If true is passed in then the elements on this mesh will no longer be (re)partitioned, and the nodes on this mesh will only be repartitioned if they are found "orphaned" via coarsening or other removal of the last element responsible for their node/element processor id consistency. More...
 
bool skip_noncritical_partitioning () const
 
void skip_partitioning (bool skip)
 If true is passed in then nothing on this mesh will be (re)partitioned. More...
 
bool skip_partitioning () const
 
void add_ghosting_functor (GhostingFunctor &ghosting_functor)
 Adds a functor which can specify ghosting requirements for use on distributed meshes. More...
 
void add_ghosting_functor (std::shared_ptr< GhostingFunctor > ghosting_functor)
 Adds a functor which can specify ghosting requirements for use on distributed meshes. More...
 
void remove_ghosting_functor (GhostingFunctor &ghosting_functor)
 Removes a functor which was previously added to the set of ghosting functors. More...
 
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin () const
 Beginning of range of ghosting functors. More...
 
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end () const
 End of range of ghosting functors. More...
 
GhostingFunctordefault_ghosting ()
 Default ghosting functor. More...
 
void subdomain_ids (std::set< subdomain_id_type > &ids, const bool global=true) const
 Constructs a list of all subdomain identifiers in the local mesh if global == false, and in the global mesh if global == true (default). More...
 
subdomain_id_type n_subdomains () const
 
subdomain_id_type n_local_subdomains () const
 
unsigned int n_partitions () const
 
std::string get_info (const unsigned int verbosity=0, const bool global=true) const
 
void print_info (std::ostream &os=libMesh::out, const unsigned int verbosity=0, const bool global=true) const
 Prints relevant information about the mesh. More...
 
void all_second_order (const bool full_ordered=true)
 Calls the range-based version of this function with a range consisting of all elements in the mesh. More...
 
virtual void all_complete_order ()
 Calls the range-based version of this function with a range consisting of all elements in the mesh. More...
 
unsigned int recalculate_n_partitions ()
 In a few (very rare) cases, the user may have manually tagged the elements with specific processor IDs by hand, without using a partitioner. More...
 
std::unique_ptr< PointLocatorBasesub_point_locator () const
 
void set_point_locator_close_to_point_tol (Real val)
 Set value used by PointLocatorBase::close_to_point_tol(). More...
 
Real get_point_locator_close_to_point_tol () const
 
void clear_point_locator ()
 Releases the current PointLocator object. More...
 
void set_count_lower_dim_elems_in_point_locator (bool count_lower_dim_elems)
 In the point locator, do we count lower dimensional elements when we refine point locator regions? This is relevant in tree-based point locators, for example. More...
 
bool get_count_lower_dim_elems_in_point_locator () const
 Get the current value of _count_lower_dim_elems_in_point_locator. More...
 
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 (std::string_view name) const
 
 ABSTRACT_ELEM_ITERATORS (,) ABSTRACT_ELEM_ITERATORS(active_
 
 ABSTRACT_ELEM_ITERATORS (ancestor_,) ABSTRACT_ELEM_ITERATORS(subactive_
 
 ABSTRACT_ELEM_ITERATORS (local_,) ABSTRACT_ELEM_ITERATORS(unpartitioned_
 
 ABSTRACT_ELEM_ITERATORS (facelocal_,) ABSTRACT_ELEM_ITERATORS(level_
 
unsigned int level ABSTRACT_ELEM_ITERATORS (pid_, processor_id_type pid) ABSTRACT_ELEM_ITERATORS(type_
 
unsigned int level ElemType type ABSTRACT_ELEM_ITERATORS (active_subdomain_, subdomain_id_type sid) ABSTRACT_ELEM_ITERATORS(active_subdomain_set_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss ABSTRACT_ELEM_ITERATORS (not_active_,) ABSTRACT_ELEM_ITERATORS(not_ancestor_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss ABSTRACT_ELEM_ITERATORS (not_subactive_,) ABSTRACT_ELEM_ITERATORS(not_local_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss ABSTRACT_ELEM_ITERATORS (not_level_, unsigned int level) ABSTRACT_ELEM_ITERATORS(active_local_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss ABSTRACT_ELEM_ITERATORS (active_not_local_,) ABSTRACT_ELEM_ITERATORS(active_unpartitioned_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss ABSTRACT_ELEM_ITERATORS (active_type_, ElemType type) ABSTRACT_ELEM_ITERATORS(active_pid_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid ABSTRACT_ELEM_ITERATORS (local_level_, unsigned int level) ABSTRACT_ELEM_ITERATORS(local_not_level_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level ABSTRACT_ELEM_ITERATORS (active_local_subdomain_, subdomain_id_type sid) ABSTRACT_ELEM_ITERATORS(active_local_subdomain_set_
 
 ABSTRACT_ELEM_ITERATORS (semilocal_,) ABSTRACT_ELEM_ITERATORS(ghost_
 
 ABSTRACT_ELEM_ITERATORS (active_semilocal_,) ABSTRACT_ELEM_ITERATORS(evaluable_
 
const DofMap &dof_map LIBMESH_COMMA unsigned int std::string & set_subdomain_name_map ()
 
const std::map< subdomain_id_type, std::string > & get_subdomain_name_map () const
 
void copy_constraint_rows (const MeshBase &other_mesh)
 Copy the constraints from the other mesh to this mesh. More...
 
template<typename T >
void copy_constraint_rows (const SparseMatrix< T > &constraint_operator)
 Copy the constraints from the given matrix to this mesh. More...
 
constraint_rows_typeget_constraint_rows ()
 
const constraint_rows_typeget_constraint_rows () const
 
void cache_elem_dims ()
 
void cache_elem_data ()
 
void detect_interior_parents ()
 Search the mesh for elements that have a neighboring element of dim+1 and set that element as the interior parent. More...
 
const std::set< subdomain_id_type > & get_mesh_subdomains () const
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Public Attributes

unsigned int level
 
processor_id_type pid unsigned int level
 
unsigned int level ElemType type
 
unsigned int level ElemType type std::set< subdomain_id_typess
 
processor_id_type pid unsigned int level std::set< subdomain_id_typess
 
processor_id_type pid
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag
 
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node_nodes
 Move node and elements from a DistributedMesh. More...
 
dofobject_container< Elem_elements
 The elements in the mesh. More...
 
bool _is_serial
 A boolean remembering whether we're serialized or not. More...
 
bool _is_serial_on_proc_0
 A boolean remembering whether we're serialized to proc 0 or not. More...
 
bool _deleted_coarse_elements
 A boolean remembering whether we've recently deleted top-level elements or not. More...
 
dof_id_type _n_nodes
 Cached data from the last renumber_nodes_and_elements call. More...
 
dof_id_type _n_elem
 
dof_id_type _max_node_id
 
dof_id_type _max_elem_id
 
dof_id_type _next_free_local_node_id
 Guaranteed globally unused IDs for use when adding new nodes or elements. More...
 
dof_id_type _next_free_local_elem_id
 
dof_id_type _next_free_unpartitioned_node_id
 
dof_id_type _next_free_unpartitioned_elem_id
 
unique_id_type _next_unpartitioned_unique_id
 The next available unique id for assigning ids to unpartitioned DOF objects. More...
 
std::set< Elem * > _extra_ghost_elems
 These are extra ghost elements that we want to make sure not to delete when we call delete_remote_elements() More...
 

Protected Types

typedef variant_filter_iterator< MeshBase::Predicate, Elem * > elem_filter_iter
 The original iterator classes weren't properly const-safe; relying on their const-incorrectness is now deprecated. More...
 
typedef variant_filter_iterator< MeshBase::Predicate, Elem *const, Elem *const &, Elem *const *, const Elem *const, const Elem *const &, const Elem *const * > elem_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, Elem *const, Elem *const &, Elem *const * > const_elem_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, const Elem *const, const Elem *const &, const Elem *const * > const_elem_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, Node * > node_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, Node *const, Node *const &, Node *const *, const Node *const, const Node *const &, const Node *const * > node_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, Node *const, Node *const &, Node *const * > const_node_filter_iter
 
typedef variant_filter_iterator< MeshBase::Predicate, const Node *const, const Node *const &, const Node *const * > const_node_filter_iter
 

Protected Member Functions

void post_dofobject_moves (MeshBase &&other_mesh)
 Moves any superclass data (e.g. More...
 
bool nodes_and_elements_equal (const MeshBase &other_mesh) const
 Tests for equality of all elements and nodes in the mesh. More...
 
unsigned intset_n_partitions ()
 
void size_elem_extra_integers ()
 Size extra-integer arrays of all elements in the mesh. More...
 
void size_node_extra_integers ()
 Size extra-integer arrays of all nodes in the mesh. More...
 
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > merge_extra_integer_names (const MeshBase &other)
 Merge extra-integer arrays from an other mesh. More...
 

Protected Attributes

std::unique_ptr< BoundaryInfoboundary_info
 This class holds the boundary information. More...
 
unsigned int _n_parts
 The number of partitions the mesh has. More...
 
ElemMappingType _default_mapping_type
 The default mapping type (typically Lagrange) between master and physical space to assign to newly added elements. More...
 
unsigned char _default_mapping_data
 The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational bases) to assign to newly added elements. More...
 
bool _is_prepared
 Flag indicating if the mesh has been prepared for use. More...
 
std::unique_ptr< PointLocatorBase_point_locator
 A PointLocator class for this mesh. More...
 
bool _count_lower_dim_elems_in_point_locator
 Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based point locators, for example. More...
 
std::unique_ptr< Partitioner_partitioner
 A partitioner to use at each prepare_for_use(). More...
 
unique_id_type _next_unique_id
 The next available unique id for assigning ids to DOF objects. More...
 
bool _skip_noncritical_partitioning
 If this is true then no partitioning should be done with the possible exception of orphaned nodes. More...
 
bool _skip_all_partitioning
 If this is true then no partitioning should be done. More...
 
bool _skip_renumber_nodes_and_elements
 If this is true then renumbering will be kept to a minimum. More...
 
bool _skip_find_neighbors
 If this is true then we will skip find_neighbors in prepare_for_use. More...
 
bool _allow_remote_element_removal
 If this is false then even on DistributedMesh remote elements will not be deleted during mesh preparation. More...
 
std::map< subdomain_id_type, std::string > _block_id_to_name
 This structure maintains the mapping of named blocks for file formats that support named blocks. More...
 
std::set< unsigned char > _elem_dims
 We cache the dimension of the elements present in the mesh. More...
 
std::set< subdomain_id_type_mesh_subdomains
 We cache the subdomain ids of the elements present in the mesh. More...
 
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
 Map from "element set code" to list of set ids to which that element belongs (and vice-versa). More...
 
std::map< MeshBase::elemset_type, dof_id_type_elemset_codes_inverse_map
 
MeshBase::elemset_type _all_elemset_ids
 
unsigned char _spatial_dimension
 The "spatial dimension" of the Mesh. More...
 
std::vector< std::string > _elem_integer_names
 The array of names for integer data associated with each element in the mesh. More...
 
std::vector< dof_id_type_elem_integer_default_values
 The array of default initialization values for integer data associated with each element in the mesh. More...
 
std::vector< std::string > _node_integer_names
 The array of names for integer data associated with each node in the mesh. More...
 
std::vector< dof_id_type_node_integer_default_values
 The array of default initialization values for integer data associated with each node in the mesh. More...
 
std::unique_ptr< GhostingFunctor_default_ghosting
 The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior. More...
 
std::set< GhostingFunctor * > _ghosting_functors
 The list of all GhostingFunctor objects to be used when distributing a DistributedMesh. More...
 
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > > _shared_functors
 Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form. More...
 
constraint_rows_type _constraint_rows
 
Real _point_locator_close_to_point_tol
 If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we create. More...
 
const Parallel::Communicator_communicator
 

Detailed Description

Definition at line 34 of file parallel_mesh.h.

Member Typedef Documentation

◆ const_elem_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Elem * const, Elem * const &, Elem * const *> libMesh::MeshBase::const_elem_filter_iter
protectedinherited

Definition at line 2052 of file mesh_base.h.

◆ const_elem_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, const Elem * const, const Elem * const &, const Elem * const *> libMesh::MeshBase::const_elem_filter_iter
protectedinherited

Definition at line 2072 of file mesh_base.h.

◆ const_node_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Node * const, Node * const &, Node * const *> libMesh::MeshBase::const_node_filter_iter
protectedinherited

Definition at line 2059 of file mesh_base.h.

◆ const_node_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, const Node * const, const Node * const &, const Node * const *> libMesh::MeshBase::const_node_filter_iter
protectedinherited

Definition at line 2085 of file mesh_base.h.

◆ constraint_rows_mapped_type

typedef std::vector<std::pair<std::pair<const Elem *, unsigned int>, Real> > libMesh::MeshBase::constraint_rows_mapped_type
inherited

Definition at line 1674 of file mesh_base.h.

◆ constraint_rows_type

Definition at line 1675 of file mesh_base.h.

◆ dofobject_container [1/2]

template<typename Obj >
using libMesh::DistributedMesh::dofobject_container = mapvector<Obj *, dof_id_type>
inherited

Definition at line 63 of file distributed_mesh.h.

◆ dofobject_container [2/2]

using libMesh::DistributedMesh::dofobject_container = chunked_mapvector<Obj *, dof_id_type, LIBMESH_MAPVECTOR_CHUNK_SIZE>
inherited

Definition at line 65 of file distributed_mesh.h.

◆ elem_filter_iter [1/2]

The original iterator classes weren't properly const-safe; relying on their const-incorrectness is now deprecated.

Definition at line 2047 of file mesh_base.h.

◆ elem_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, Elem * const, Elem * const &, Elem * const *, const Elem * const, const Elem * const &, const Elem * const *> libMesh::MeshBase::elem_filter_iter
protectedinherited

Definition at line 2067 of file mesh_base.h.

◆ elemset_type

typedef std::set<elemset_id_type> libMesh::MeshBase::elemset_type
inherited

Typedef for the "set" container used to store elemset ids.

The main requirements are that the entries be sorted and unique, so std::set works for this, but there may be more efficient alternatives.

Definition at line 297 of file mesh_base.h.

◆ node_filter_iter [1/2]

Definition at line 2054 of file mesh_base.h.

◆ node_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, Node * const, Node * const &, Node * const *, const Node * const, const Node * const &, const Node * const *> libMesh::MeshBase::node_filter_iter
protectedinherited

Definition at line 2080 of file mesh_base.h.

◆ Predicate

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

Definition at line 1380 of file mesh_base.h.

Constructor & Destructor Documentation

◆ ParallelMesh() [1/2]

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

Definition at line 38 of file parallel_mesh.h.

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

◆ ParallelMesh() [2/2]

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

Definition at line 42 of file parallel_mesh.h.

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

◆ ~ParallelMesh()

libMesh::ParallelMesh::~ParallelMesh ( )
default

Member Function Documentation

◆ ABSTRACT_ELEM_ITERATORS() [1/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [2/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( ancestor_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [3/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( local_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [4/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( facelocal_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [5/15]

unsigned int level libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( pid_  ,
processor_id_type  pid 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [6/15]

unsigned int level ElemType type libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_subdomain_  ,
subdomain_id_type  sid 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [7/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( not_active_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [8/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( not_subactive_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [9/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( not_level_  ,
unsigned int  level 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [10/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_not_local_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [11/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_type_  ,
ElemType  type 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [12/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss processor_id_type pid libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( local_level_  ,
unsigned int  level 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [13/15]

unsigned int level ElemType type std::set<subdomain_id_type> ss processor_id_type pid unsigned int level libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_local_subdomain_  ,
subdomain_id_type  sid 
)
inherited

◆ ABSTRACT_ELEM_ITERATORS() [14/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( semilocal_  )
inherited

◆ ABSTRACT_ELEM_ITERATORS() [15/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_semilocal_  )
inherited

◆ active_local_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_local_subdomain_elements_ptr_range ( subdomain_id_type  sid)
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 365 of file distributed_mesh.h.

365 { return active_local_subdomain_element_ptr_range(sid); }

◆ active_local_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_local_subdomain_elements_ptr_range ( subdomain_id_type  sid) const
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 366 of file distributed_mesh.h.

366 { return active_local_subdomain_element_ptr_range(sid); }

◆ active_subdomain_elements_ptr_range() [1/2]

unsigned int level ElemType type std::set<subdomain_id_type> virtual ss SimpleRange<element_iterator> libMesh::DistributedMesh::active_subdomain_elements_ptr_range ( subdomain_id_type  sid)
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 363 of file distributed_mesh.h.

363 { return active_subdomain_element_ptr_range(sid); }

◆ active_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_subdomain_elements_ptr_range ( subdomain_id_type  sid) const
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 364 of file distributed_mesh.h.

364 { return active_subdomain_element_ptr_range(sid); }

◆ active_subdomain_set_elements_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type ss)
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 367 of file distributed_mesh.h.

References libMesh::DistributedMesh::ss.

367 { return active_subdomain_set_element_ptr_range(ss); }
unsigned int level ElemType type std::set< subdomain_id_type > ss

◆ active_subdomain_set_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type ss) const
inlinefinaloverridevirtualinherited

Implements libMesh::MeshBase.

Definition at line 368 of file distributed_mesh.h.

References libMesh::DistributedMesh::ss.

368 { return active_subdomain_set_element_ptr_range(ss); }
unsigned int level ElemType type std::set< subdomain_id_type > ss

◆ add_elem() [1/2]

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

Add elem e to the end of the element array.

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

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

Implements libMesh::MeshBase.

Definition at line 532 of file distributed_mesh.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_next_free_local_elem_id, libMesh::DistributedMesh::_next_free_unpartitioned_elem_id, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

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

533 {
534  // Don't try to add nullptrs!
535  libmesh_assert(e);
536 
537  // Trying to add an existing element is a no-op
538  if (e->valid_id() && _elements[e->id()] == e)
539  return e;
540 
541  const processor_id_type elem_procid = e->processor_id();
542 
543  if (!e->valid_id())
544  {
545  // We should only be creating new ids past the end of the range
546  // of existing ids
547  libmesh_assert_greater_equal(_next_free_unpartitioned_elem_id,
548  _max_elem_id);
549  libmesh_assert_greater_equal(_next_free_local_elem_id, _max_elem_id);
550 
551  // Use the unpartitioned ids for unpartitioned elems, and
552  // temporarily for ghost elems
554  if (elem_procid == this->processor_id())
555  next_id = &_next_free_local_elem_id;
556  e->set_id (*next_id);
557  }
558 
559  {
560  // Advance next_ids up high enough that each is pointing to an
561  // unused id and any subsequent increments will still point us
562  // to unused ids
563  _max_elem_id = std::max(_max_elem_id,
564  static_cast<dof_id_type>(e->id()+1));
565 
568  ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
569  (this->n_processors() + 1) + this->n_processors();
572  ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
573  (this->n_processors() + 1) + this->processor_id();
574 
575 #ifndef NDEBUG
576  // We need a const dofobject_container so we don't inadvertently create
577  // nullptr entries when testing for non-nullptr ones
578  const dofobject_container<Elem> & const_elements = _elements;
579 #endif
581  libmesh_assert(!const_elements[_next_free_local_elem_id]);
582  }
583 
584  // Don't try to overwrite existing elems
585  libmesh_assert (!_elements[e->id()]);
586 
587  _elements[e->id()] = e;
588 
589  // Try to make the cached elem data more accurate
590  if (elem_procid == this->processor_id() ||
591  elem_procid == DofObject::invalid_processor_id)
592  _n_elem++;
593 
594 #ifdef LIBMESH_ENABLE_UNIQUE_ID
595  if (!e->valid_unique_id())
596  {
597  if (processor_id() == e->processor_id())
598  {
599  e->set_unique_id(_next_unique_id);
600  _next_unique_id += this->n_processors() + 1;
601  }
602  else
603  {
604  e->set_unique_id(_next_unpartitioned_unique_id);
606  }
607  }
608  else
609  {
610  _next_unique_id = std::max(_next_unique_id, e->unique_id()+1);
612  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
613  (this->n_processors() + 1) + this->processor_id();
614  }
615 #endif
616 
617  // Unpartitioned elems should be added on every processor
618  // And shouldn't be added in the same batch as ghost elems
619  // But we might be just adding on processor 0 to
620  // broadcast later
621  // #ifdef DEBUG
622  // if (elem_procid == DofObject::invalid_processor_id)
623  // {
624  // dof_id_type elem_id = e->id();
625  // this->comm().max(elem_id);
626  // libmesh_assert_equal_to (elem_id, e->id());
627  // }
628  // #endif
629 
630  // Make sure any new element is given space for any extra integers
631  // we've requested
632  e->add_extra_integers(_elem_integer_names.size(),
634 
635  // And set mapping type and data on any new element
636  e->set_mapping_type(this->default_mapping_type());
637  e->set_mapping_data(this->default_mapping_data());
638 
639  return e;
640 }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
ElemMappingType default_mapping_type() const
Returns the default master space to physical space mapping basis functions to be used on newly added ...
Definition: mesh_base.h:791
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
uint8_t processor_id_type
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
unsigned char default_mapping_data() const
Returns any default data value used by the master space to physical space mapping.
Definition: mesh_base.h:809
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944
dof_id_type _next_free_unpartitioned_elem_id
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id
uint8_t dof_id_type
Definition: id_types.h:67

◆ add_elem() [2/2]

Elem * libMesh::DistributedMesh::add_elem ( std::unique_ptr< Elem e)
finaloverridevirtualinherited

Version of add_elem() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Elem is transferred to the Mesh when this function is called, and it should play more nicely with the Elem::build() API which has always returned a std::unique_ptr.

Implements libMesh::MeshBase.

Definition at line 644 of file distributed_mesh.C.

References libMesh::DistributedMesh::add_elem().

645 {
646  // The mesh now takes ownership of the Elem. Eventually the guts of
647  // add_elem() will get moved to a private helper function, and
648  // calling add_elem() directly will be deprecated.
649  return add_elem(e.release());
650 }
virtual Elem * add_elem(Elem *e) override final
Add elem e to the end of the element array.

◆ add_elem_data()

template<typename T >
std::vector< unsigned int > libMesh::MeshBase::add_elem_data ( const std::vector< std::string > &  names,
bool  allocate_data = true,
const std::vector< T > *  default_values = nullptr 
)
inlineinherited

Register data (of type T) to be added to each element in the mesh.

If the mesh already has elements, data is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to meaningless memcpy output if default_values is null.

Returns
The starting index number for the new data, or for the existing data if one by the same name has already been added.

If type T is larger than dof_id_type, each datum will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2221 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and libMesh::MeshBase::size_elem_extra_integers().

2224 {
2225  libmesh_assert(!default_values || default_values->size() == names.size());
2226 
2227  std::vector<unsigned int> returnval(names.size());
2228 
2229  const std::size_t old_size = _elem_integer_names.size();
2230 
2231  for (auto i : index_range(names))
2232  returnval[i] =
2233  this->add_elem_datum<T>(names[i], false,
2234  default_values ?
2235  (*default_values)[i] : nullptr);
2236 
2237  if (allocate_data && old_size != _elem_integer_names.size())
2238  this->size_elem_extra_integers();
2239 
2240  return returnval;
2241 }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
libmesh_assert(ctx)
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
void size_elem_extra_integers()
Size extra-integer arrays of all elements in the mesh.
Definition: mesh_base.C:1843

◆ add_elem_datum()

template<typename T >
unsigned int libMesh::MeshBase::add_elem_datum ( const std::string &  name,
bool  allocate_data = true,
const T *  default_value = nullptr 
)
inlineinherited

Register a datum (of type T) to be added to each element in the mesh.

If the mesh already has elements, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_elem_data instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_elem_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to *default_value if default_value is not null, or to meaningless memcpy output otherwise.

Returns
The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2197 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::add_elem_integer(), libMesh::DofObject::invalid_id, and libMesh::MeshBase::size_elem_extra_integers().

Referenced by ExtraIntegersTest::build_mesh().

2200 {
2201  const std::size_t old_size = _elem_integer_names.size();
2202 
2203  unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
2204  std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
2205  if (default_value)
2206  std::memcpy(int_data.data(), default_value, sizeof(T));
2207 
2208  unsigned int start_idx = this->add_elem_integer(name, false, int_data[0]);
2209  for (unsigned int i=0; i != n_more_integers; ++i)
2210  this->add_elem_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
2211 
2212  if (allocate_data && old_size != _elem_integer_names.size())
2213  this->size_elem_extra_integers();
2214 
2215  return start_idx;
2216 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
unsigned int add_elem_integer(std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
Register an integer datum (of type dof_id_type) to be added to each element in the mesh...
Definition: mesh_base.C:512
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
void size_elem_extra_integers()
Size extra-integer arrays of all elements in the mesh.
Definition: mesh_base.C:1843
uint8_t dof_id_type
Definition: id_types.h:67

◆ add_elem_integer()

unsigned int libMesh::MeshBase::add_elem_integer ( std::string  name,
bool  allocate_data = true,
dof_id_type  default_value = DofObject::invalid_id 
)
inherited

Register an integer datum (of type dof_id_type) to be added to each element in the mesh.

If the mesh already has elements, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_elem_integers instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_elem_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to default_value

Returns
The index number for the new datum, or for the existing datum if one by the same name has already been added.

Definition at line 512 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::index_range(), libMesh::Quality::name(), and libMesh::MeshBase::size_elem_extra_integers().

Referenced by libMesh::MeshBase::add_elem_datum(), libMesh::BoundaryInfo::add_elements(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_header(), ExtraIntegersTest::test_helper(), MeshStitchTest::testMeshStitchElemsets(), and WriteElemsetData::testWriteImpl().

515 {
516  for (auto i : index_range(_elem_integer_names))
517  if (_elem_integer_names[i] == name)
518  {
519  libmesh_assert_less(i, _elem_integer_default_values.size());
520  _elem_integer_default_values[i] = default_value;
521  return i;
522  }
523 
524  libmesh_assert_equal_to(_elem_integer_names.size(),
526  _elem_integer_names.push_back(std::move(name));
527  _elem_integer_default_values.push_back(default_value);
528  if (allocate_data)
529  this->size_elem_extra_integers();
530  return _elem_integer_names.size()-1;
531 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
void size_elem_extra_integers()
Size extra-integer arrays of all elements in the mesh.
Definition: mesh_base.C:1843

◆ add_elem_integers()

std::vector< unsigned int > libMesh::MeshBase::add_elem_integers ( const std::vector< std::string > &  names,
bool  allocate_data = true,
const std::vector< dof_id_type > *  default_values = nullptr 
)
inherited

Register integer data (of type dof_id_type) to be added to each element in the mesh, one string name for each new integer.

If the mesh already has elements, data by default is allocated in each of them.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to DofObject::invalid_id if default_values is null.

Returns
The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

Definition at line 535 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::Quality::name(), and libMesh::MeshBase::size_elem_extra_integers().

Referenced by libMesh::MeshBase::merge_extra_integer_names(), and libMesh::XdrIO::read_header().

538 {
539  libmesh_assert(!default_values || default_values->size() == names.size());
540  libmesh_assert_equal_to(_elem_integer_names.size(), _elem_integer_default_values.size());
541 
542  std::unordered_map<std::string, std::size_t> name_indices;
543  for (auto i : index_range(_elem_integer_names))
544  name_indices[_elem_integer_names[i]] = i;
545 
546  std::vector<unsigned int> returnval(names.size());
547 
548  bool added_an_integer = false;
549  for (auto i : index_range(names))
550  {
551  const std::string & name = names[i];
552  auto it = name_indices.find(name);
553  if (it != name_indices.end())
554  {
555  returnval[i] = it->second;
556  _elem_integer_default_values[it->second] =
557  default_values ? (*default_values)[i] : DofObject::invalid_id;
558  }
559  else
560  {
561  returnval[i] = _elem_integer_names.size();
562  name_indices[name] = returnval[i];
563  _elem_integer_names.push_back(name);
565  (default_values ? (*default_values)[i] : DofObject::invalid_id);
566  added_an_integer = true;
567  }
568  }
569 
570  if (allocate_data && added_an_integer)
571  this->size_elem_extra_integers();
572 
573  return returnval;
574 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
libmesh_assert(ctx)
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
void size_elem_extra_integers()
Size extra-integer arrays of all elements in the mesh.
Definition: mesh_base.C:1843

◆ add_elemset_code()

void libMesh::MeshBase::add_elemset_code ( dof_id_type  code,
MeshBase::elemset_type  id_set 
)
inherited

Tabulate a user-defined "code" for elements which belong to the element sets specified in id_set.

For example, suppose that we have two elemsets A and B with the following Elem ids: Elemset A = {1, 3} Elemset B = {2, 3}

This implies the following mapping from elem id to elemset id: Elem 1 -> {A} Elem 2 -> {B} Elem 3 -> {A,B}

In this case, we would need to tabulate three different elemset codes, e.g.: 0 -> {A} 1 -> {B} 2 -> {A,B}

Also sets up the inverse mapping, so that if one knows all the element sets an Elem belongs to, one can look up the corresponding elemset code.

Definition at line 350 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids, libMesh::MeshBase::_elemset_codes, and libMesh::MeshBase::_elemset_codes_inverse_map.

Referenced by libMesh::MeshBase::change_elemset_code(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testMeshStitchElemsets(), and WriteElemsetData::testWriteImpl().

351 {
352  // Populate inverse map, stealing id_set's resources
353  auto [it1, inserted1] = _elemset_codes_inverse_map.emplace(std::move(id_set), code);
354 
355  // Reference to the newly inserted (or previously existing) id_set
356  const auto & inserted_id_set = it1->first;
357 
358  // Keep track of all elemset ids ever added for O(1) n_elemsets()
359  // performance. Only need to do this if we didn't know about this
360  // id_set before...
361  if (inserted1)
362  _all_elemset_ids.insert(inserted_id_set.begin(), inserted_id_set.end());
363 
364  // Take the address of the newly emplaced set to use in
365  // _elemset_codes, avoid duplicating std::set storage
366  auto [it2, inserted2] = _elemset_codes.emplace(code, &inserted_id_set);
367 
368  // Throw an error if this code already exists with a pointer to a
369  // different set of ids.
370  libmesh_error_msg_if(!inserted2 && it2->second != &inserted_id_set,
371  "The elemset code " << code << " already exists with a different id_set.");
372 }
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
MeshBase::elemset_type _all_elemset_ids
Definition: mesh_base.h:1926

◆ add_extra_ghost_elem()

void libMesh::DistributedMesh::add_extra_ghost_elem ( Elem e)
virtualinherited

Inserts the element and adds it to a list of elements that should not get deleted or have their descendants deleted by delete_remote_elements.

This is handy for inserting otherwise off-processor elements that you want to keep track of on this processor.

Definition at line 1786 of file distributed_mesh.C.

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

1787 {
1788  // First add the elem like normal
1789  add_elem(e);
1790 
1791  // Now add it to the set that won't be deleted when we call
1792  // delete_remote_elements()
1793  _extra_ghost_elems.insert(e);
1794 }
virtual Elem * add_elem(Elem *e) override final
Add elem e to the end of the element array.
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...

◆ add_ghosting_functor() [1/2]

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

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::DofMap::add_algebraic_ghosting_functor(), libMesh::DofMap::add_coupling_functor(), libMesh::MeshBase::add_ghosting_functor(), main(), libMesh::MeshBase::MeshBase(), and EquationSystemsTest::testDisableDefaultGhosting().

1245  { _ghosting_functors.insert(&ghosting_functor); }
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991

◆ add_ghosting_functor() [2/2]

void libMesh::MeshBase::add_ghosting_functor ( std::shared_ptr< 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 when using this method is managed by the shared_ptr mechanism.

Definition at line 1255 of file mesh_base.h.

References libMesh::MeshBase::_shared_functors, and libMesh::MeshBase::add_ghosting_functor().

1256  { _shared_functors[ghosting_functor.get()] = ghosting_functor;
1257  this->add_ghosting_functor(*ghosting_functor); }
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > > _shared_functors
Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form...
Definition: mesh_base.h:1997
void add_ghosting_functor(GhostingFunctor &ghosting_functor)
Adds a functor which can specify ghosting requirements for use on distributed meshes.
Definition: mesh_base.h:1244

◆ add_node() [1/2]

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

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 800 of file distributed_mesh.C.

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

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

801 {
802  // Don't try to add nullptrs!
803  libmesh_assert(n);
804 
805  // Trying to add an existing node is a no-op
806  if (n->valid_id() && _nodes[n->id()] == n)
807  return n;
808 
809  const processor_id_type node_procid = n->processor_id();
810 
811  if (!n->valid_id())
812  {
813  // We should only be creating new ids past the end of the range
814  // of existing ids
815  libmesh_assert_greater_equal(_next_free_unpartitioned_node_id,
816  _max_node_id);
817  libmesh_assert_greater_equal(_next_free_local_node_id, _max_node_id);
818 
819  // Use the unpartitioned ids for unpartitioned nodes,
820  // and temporarily for ghost nodes
822  if (node_procid == this->processor_id())
823  next_id = &_next_free_local_node_id;
824  n->set_id (*next_id);
825  }
826 
827  {
828  // Advance next_ids up high enough that each is pointing to an
829  // unused id and any subsequent increments will still point us
830  // to unused ids
831  _max_node_id = std::max(_max_node_id,
832  static_cast<dof_id_type>(n->id()+1));
833 
836  ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
837  (this->n_processors() + 1) + this->n_processors();
840  ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
841  (this->n_processors() + 1) + this->processor_id();
842 
843 #ifndef NDEBUG
844  // We need a const dofobject_container so we don't inadvertently create
845  // nullptr entries when testing for non-nullptr ones
846  const dofobject_container<Node> & const_nodes = _nodes;
847 #endif
850  }
851 
852  // Don't try to overwrite existing nodes
853  libmesh_assert (!_nodes[n->id()]);
854 
855  _nodes[n->id()] = n;
856 
857  // Try to make the cached node data more accurate
858  if (node_procid == this->processor_id() ||
859  node_procid == DofObject::invalid_processor_id)
860  _n_nodes++;
861 
862 #ifdef LIBMESH_ENABLE_UNIQUE_ID
863  if (!n->valid_unique_id())
864  {
865  if (processor_id() == n->processor_id())
866  {
867  n->set_unique_id(_next_unique_id);
868  _next_unique_id += this->n_processors() + 1;
869  }
870  else
871  {
872  n->set_unique_id(_next_unpartitioned_unique_id);
874  }
875  }
876  else
877  {
878  _next_unique_id = std::max(_next_unique_id, n->unique_id()+1);
880  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
881  (this->n_processors() + 1) + this->processor_id();
882  }
883 #endif
884 
885  n->add_extra_integers(_node_integer_names.size(),
887 
888  // Unpartitioned nodes should be added on every processor
889  // And shouldn't be added in the same batch as ghost nodes
890  // But we might be just adding on processor 0 to
891  // broadcast later
892  // #ifdef DEBUG
893  // if (node_procid == DofObject::invalid_processor_id)
894  // {
895  // dof_id_type node_id = n->id();
896  // this->comm().max(node_id);
897  // libmesh_assert_equal_to (node_id, n->id());
898  // }
899  // #endif
900 
901  return n;
902 }
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
dof_id_type _next_free_local_node_id
Guaranteed globally unused IDs for use when adding new nodes or elements.
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
uint8_t processor_id_type
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
dof_id_type _next_free_unpartitioned_node_id
std::vector< dof_id_type > _node_integer_default_values
The array of default initialization values for integer data associated with each node in the mesh...
Definition: mesh_base.h:1956
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ add_node() [2/2]

Node * libMesh::DistributedMesh::add_node ( std::unique_ptr< Node n)
finaloverridevirtualinherited

Version of add_node() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Node is transferred to the Mesh when this function is called, and it should play more nicely with the Node::build() API which has always returned a std::unique_ptr.

Implements libMesh::MeshBase.

Definition at line 904 of file distributed_mesh.C.

References libMesh::DistributedMesh::add_node().

905 {
906  // The mesh now takes ownership of the Node. Eventually the guts of
907  // add_node() will get moved to a private helper function, and
908  // calling add_node() directly will be deprecated.
909  return add_node(n.release());
910 }
virtual Node * add_node(Node *n) override final
Add Node n to the end of the vertex array.

◆ add_node_data()

template<typename T >
std::vector< unsigned int > libMesh::MeshBase::add_node_data ( const std::vector< std::string > &  name,
bool  allocate_data = true,
const std::vector< T > *  default_values = nullptr 
)
inlineinherited

Register data (of type T) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to meaningless memcpy output if default_values is null.

Returns
The starting index number for the new data, or for the existing data if one by the same name has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2270 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and libMesh::MeshBase::size_node_extra_integers().

2273 {
2274  libmesh_assert(!default_values || default_values->size() == names.size());
2275 
2276  std::vector<unsigned int> returnval(names.size());
2277 
2278  const std::size_t old_size = _node_integer_names.size();
2279 
2280  for (auto i : index_range(names))
2281  returnval[i] =
2282  this->add_node_datum<T>(names[i], false,
2283  default_values ?
2284  (*default_values)[i] : nullptr);
2285 
2286  if (allocate_data && old_size != _node_integer_names.size())
2287  this->size_node_extra_integers();
2288 
2289  return returnval;
2290 }
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
libmesh_assert(ctx)
void size_node_extra_integers()
Size extra-integer arrays of all nodes in the mesh.
Definition: mesh_base.C:1852
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ add_node_datum()

template<typename T >
unsigned int libMesh::MeshBase::add_node_datum ( const std::string &  name,
bool  allocate_data = true,
const T *  default_value = nullptr 
)
inlineinherited

Register a datum (of type T) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_node_data instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_node_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to *default_value if default_value is not null, or to meaningless memcpy output otherwise.

Returns
The starting index number for the new datum, or for the existing datum if one by the same name has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2246 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::add_node_integer(), libMesh::DofObject::invalid_id, and libMesh::MeshBase::size_node_extra_integers().

Referenced by ExtraIntegersTest::build_mesh(), libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

2249 {
2250  const std::size_t old_size = _node_integer_names.size();
2251 
2252  unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
2253  std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
2254  if (default_value)
2255  std::memcpy(int_data.data(), default_value, sizeof(T));
2256 
2257  unsigned int start_idx = this->add_node_integer(name, false, int_data[0]);
2258  for (unsigned int i=0; i != n_more_integers; ++i)
2259  this->add_node_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
2260 
2261  if (allocate_data && old_size != _node_integer_names.size())
2262  this->size_node_extra_integers();
2263 
2264  return start_idx;
2265 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
void size_node_extra_integers()
Size extra-integer arrays of all nodes in the mesh.
Definition: mesh_base.C:1852
unsigned int add_node_integer(std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
Register an integer datum (of type dof_id_type) to be added to each node in the mesh.
Definition: mesh_base.C:601
uint8_t dof_id_type
Definition: id_types.h:67

◆ add_node_integer()

unsigned int libMesh::MeshBase::add_node_integer ( std::string  name,
bool  allocate_data = true,
dof_id_type  default_value = DofObject::invalid_id 
)
inherited

Register an integer datum (of type dof_id_type) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_node_integers instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_node_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to default_value

Returns
The index number for the new datum, or for the existing datum if one by the same name has already been added.

Definition at line 601 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::index_range(), libMesh::Quality::name(), and libMesh::MeshBase::size_node_extra_integers().

Referenced by libMesh::MeshBase::add_node_datum(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::CheckpointIO::read_header(), and ExtraIntegersTest::test_helper().

604 {
605  for (auto i : index_range(_node_integer_names))
606  if (_node_integer_names[i] == name)
607  {
608  libmesh_assert_less(i, _node_integer_default_values.size());
609  _node_integer_default_values[i] = default_value;
610  return i;
611  }
612 
613  libmesh_assert_equal_to(_node_integer_names.size(),
615  _node_integer_names.push_back(std::move(name));
616  _node_integer_default_values.push_back(default_value);
617  if (allocate_data)
618  this->size_node_extra_integers();
619  return _node_integer_names.size()-1;
620 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
void size_node_extra_integers()
Size extra-integer arrays of all nodes in the mesh.
Definition: mesh_base.C:1852
std::vector< dof_id_type > _node_integer_default_values
The array of default initialization values for integer data associated with each node in the mesh...
Definition: mesh_base.h:1956
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ add_node_integers()

std::vector< unsigned int > libMesh::MeshBase::add_node_integers ( const std::vector< std::string > &  names,
bool  allocate_data = true,
const std::vector< dof_id_type > *  default_values = nullptr 
)
inherited

Register integer data (of type dof_id_type) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to DofObject::invalid_id if default_values is null.

Returns
The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

Definition at line 624 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::Quality::name(), and libMesh::MeshBase::size_node_extra_integers().

Referenced by libMesh::MeshBase::merge_extra_integer_names(), and libMesh::XdrIO::read_header().

627 {
628  libmesh_assert(!default_values || default_values->size() == names.size());
629  libmesh_assert_equal_to(_node_integer_names.size(), _node_integer_default_values.size());
630 
631  std::unordered_map<std::string, std::size_t> name_indices;
632  for (auto i : index_range(_node_integer_names))
633  name_indices[_node_integer_names[i]] = i;
634 
635  std::vector<unsigned int> returnval(names.size());
636 
637  bool added_an_integer = false;
638  for (auto i : index_range(names))
639  {
640  const std::string & name = names[i];
641  auto it = name_indices.find(name);
642  if (it != name_indices.end())
643  {
644  returnval[i] = it->second;
645  _node_integer_default_values[it->second] =
646  default_values ? (*default_values)[i] : DofObject::invalid_id;
647  }
648  else
649  {
650  returnval[i] = _node_integer_names.size();
651  name_indices[name] = returnval[i];
652  _node_integer_names.push_back(name);
654  (default_values ? (*default_values)[i] : DofObject::invalid_id);
655  added_an_integer = true;
656  }
657  }
658 
659  if (allocate_data && added_an_integer)
660  this->size_node_extra_integers();
661 
662  return returnval;
663 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
libmesh_assert(ctx)
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
void size_node_extra_integers()
Size extra-integer arrays of all nodes in the mesh.
Definition: mesh_base.C:1852
std::vector< dof_id_type > _node_integer_default_values
The array of default initialization values for integer data associated with each node in the mesh...
Definition: mesh_base.h:1956
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ add_point()

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

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 761 of file distributed_mesh.C.

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

764 {
765  auto n_it = _nodes.find(id);
766  if (n_it != _nodes.end())
767  {
768  Node * n = *n_it;
769  libmesh_assert (n);
770  libmesh_assert_equal_to (n->id(), id);
771 
772  *n = p;
773  n->processor_id() = proc_id;
774 
775  return n;
776  }
777 
778  Node * n = Node::build(p, id).release();
779  n->processor_id() = proc_id;
780 
781  return DistributedMesh::add_node(n);
782 }
virtual Node * add_node(Node *n) override final
Add Node n to the end of the vertex array.
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)
static std::unique_ptr< Node > build(const Node &n)
Definition: node.h:315

◆ all_complete_order()

void libMesh::MeshBase::all_complete_order ( )
virtualinherited

Calls the range-based version of this function with a range consisting of all elements in the mesh.

Definition at line 1540 of file mesh_base.C.

References libMesh::MeshBase::all_complete_order_range().

Referenced by AllSecondOrderTest::allCompleteOrder(), and main().

1541 {
1542  this->all_complete_order_range(this->element_ptr_range());
1543 }
virtual void all_complete_order_range(const SimpleRange< element_iterator > &range)=0
Converts a set of elements in this (conforming, non-refined) mesh into "complete" order elements...

◆ all_complete_order_range()

void libMesh::UnstructuredMesh::all_complete_order_range ( const SimpleRange< element_iterator > &  range)
overridevirtualinherited

Converts a (conforming, non-refined) mesh with linear elements into a mesh with "complete" order elements, i.e.

elements which can store degrees of freedom on any vertex, edge, or face. For example, a mesh consisting of Tet4 or Tet10 will be converted to a mesh with Tet14 etc.

Implements libMesh::MeshBase.

Definition at line 1681 of file unstructured_mesh.C.

References libMesh::Elem::complete_order_equivalent_type(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_nodes(), and libMesh::MeshBase::reserve_nodes().

1682 {
1683  LOG_SCOPE("all_complete_order()", "Mesh");
1684 
1685  /*
1686  * The maximum number of new higher-order nodes we might be adding,
1687  * for use when picking unique unique_id values later. This variable
1688  * is not used unless unique ids are enabled.
1689  */
1690  unsigned int max_new_nodes_per_elem;
1691 
1692  /*
1693  * for speed-up of the \p add_point() method, we
1694  * can reserve memory. Guess the number of additional
1695  * nodes based on the element spatial dimensions and the
1696  * total number of nodes in the mesh as an upper bound.
1697  */
1698  switch (this->mesh_dimension())
1699  {
1700  case 1:
1701  /*
1702  * in 1D, there can only be order-increase from Edge2
1703  * to Edge3. Something like 1/2 of n_nodes() have
1704  * to be added
1705  */
1706  max_new_nodes_per_elem = 3 - 2;
1707  this->reserve_nodes(static_cast<unsigned int>
1708  (1.5*static_cast<double>(this->n_nodes())));
1709  break;
1710 
1711  case 2:
1712  /*
1713  * in 2D, we typically refine from Tri6 to Tri7 (1.1667 times
1714  * the nodes) but might refine from Quad4 to Quad9
1715  * (2.25 times the nodes)
1716  */
1717  max_new_nodes_per_elem = 9 - 4;
1718  this->reserve_nodes(static_cast<unsigned int>
1719  (2*static_cast<double>(this->n_nodes())));
1720  break;
1721 
1722 
1723  case 3:
1724  /*
1725  * in 3D, we typically refine from Tet10 to Tet14 (factor = 1.4)
1726  * but may go Hex8 to Hex27 (something > 3). Since in 3D there
1727  * _are_ already quite some nodes, and since we do not want to
1728  * overburden the memory by a too conservative guess, use a
1729  * moderate bound
1730  */
1731  max_new_nodes_per_elem = 27 - 8;
1732  this->reserve_nodes(static_cast<unsigned int>
1733  (2.5*static_cast<double>(this->n_nodes())));
1734  break;
1735 
1736  default:
1737  // Hm?
1738  libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
1739  }
1740 
1741  // All the real work is done in the helper function
1742  all_increased_order_range(*this, range, max_new_nodes_per_elem,
1743  [](ElemType t) {
1745  });
1746 }
ElemType
Defines an enum for geometric element types.
virtual void reserve_nodes(const dof_id_type nn)=0
Reserves space for a known number of nodes.
static ElemType complete_order_equivalent_type(const ElemType et)
Definition: elem.C:2937
unsigned int mesh_dimension() const
Definition: mesh_base.C:324
virtual dof_id_type n_nodes() const =0

◆ all_first_order()

void libMesh::UnstructuredMesh::all_first_order ( )
overridevirtualinherited

Converts a mesh with higher-order elements into a mesh with linear elements.

For example, a mesh consisting of Tet10 will be converted to a mesh with Tet4 etc.

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

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

Implements libMesh::MeshBase.

Definition at line 1466 of file unstructured_mesh.C.

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

1467 {
1468  LOG_SCOPE("all_first_order()", "Mesh");
1469 
1470  /*
1471  * when the mesh is not prepared,
1472  * at least renumber the nodes and
1473  * elements, so that the node ids
1474  * are correct
1475  */
1476  if (!this->_is_prepared)
1477  this->renumber_nodes_and_elements ();
1478 
1482  std::vector<bool> node_touched_by_me(this->max_node_id(), false);
1483 
1484  // Loop over the high-ordered elements.
1485  // First make sure they _are_ indeed high-order, and then replace
1486  // them with an equivalent first-order element.
1487  for (auto & so_elem : element_ptr_range())
1488  {
1489  libmesh_assert(so_elem);
1490 
1491  /*
1492  * build the first-order equivalent, add to
1493  * the new_elements list.
1494  */
1495  auto lo_elem = Elem::build
1497  (so_elem->type()), so_elem->parent());
1498 
1499  const unsigned short n_sides = so_elem->n_sides();
1500 
1501  for (unsigned short s=0; s != n_sides; ++s)
1502  if (so_elem->neighbor_ptr(s) == remote_elem)
1503  lo_elem->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
1504 
1505 #ifdef LIBMESH_ENABLE_AMR
1506  /*
1507  * Reset the parent links of any child elements
1508  */
1509  if (so_elem->has_children())
1510  for (unsigned int c = 0, nc = so_elem->n_children(); c != nc; ++c)
1511  {
1512  Elem * child = so_elem->child_ptr(c);
1513  if (child != remote_elem)
1514  child->set_parent(lo_elem.get());
1515  lo_elem->add_child(child, c);
1516  }
1517 
1518  /*
1519  * Reset the child link of any parent element
1520  */
1521  if (so_elem->parent())
1522  {
1523  unsigned int c =
1524  so_elem->parent()->which_child_am_i(so_elem);
1525  lo_elem->parent()->replace_child(lo_elem.get(), c);
1526  }
1527 
1528  /*
1529  * Copy as much data to the new element as makes sense
1530  */
1531  lo_elem->set_p_level(so_elem->p_level());
1532  lo_elem->set_refinement_flag(so_elem->refinement_flag());
1533  lo_elem->set_p_refinement_flag(so_elem->p_refinement_flag());
1534 #endif
1535 
1536  libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());
1537 
1538  /*
1539  * By definition the vertices of the linear and
1540  * second order element are identically numbered.
1541  * transfer these.
1542  */
1543  for (unsigned int v=0, snv=so_elem->n_vertices(); v < snv; v++)
1544  {
1545  lo_elem->set_node(v) = so_elem->node_ptr(v);
1546  node_touched_by_me[lo_elem->node_id(v)] = true;
1547  }
1548 
1549  /*
1550  * find_neighbors relies on remote_elem neighbor links being
1551  * properly maintained.
1552  */
1553  for (unsigned short s=0; s != n_sides; s++)
1554  {
1555  if (so_elem->neighbor_ptr(s) == remote_elem)
1556  lo_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
1557  }
1558 
1566  (this->get_boundary_info(), so_elem, lo_elem.get());
1567 
1568  /*
1569  * The new first-order element is ready.
1570  * Inserting it into the mesh will replace and delete
1571  * the second-order element.
1572  */
1573  lo_elem->set_id(so_elem->id());
1574 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1575  lo_elem->set_unique_id(so_elem->unique_id());
1576 #endif
1577  lo_elem->processor_id() = so_elem->processor_id();
1578  lo_elem->subdomain_id() = so_elem->subdomain_id();
1579 
1580  const unsigned int nei = so_elem->n_extra_integers();
1581  lo_elem->add_extra_integers(nei);
1582  for (unsigned int i=0; i != nei; ++i)
1583  lo_elem->set_extra_integer(i, so_elem->get_extra_integer(i));
1584 
1585  // This is probably moot but shouldn't hurt
1586  lo_elem->set_mapping_type(so_elem->mapping_type());
1587  lo_elem->set_mapping_data(so_elem->mapping_data());
1588 
1589  this->insert_elem(std::move(lo_elem));
1590  }
1591 
1592  // Deleting nodes does not invalidate iterators, so this is safe.
1593  for (const auto & node : this->node_ptr_range())
1594  if (!node_touched_by_me[node->id()])
1595  this->delete_node(node);
1596 
1597  // If crazy people applied boundary info to non-vertices and then
1598  // deleted those non-vertices, we should make sure their boundary id
1599  // caches are correct.
1601 
1602  // On hanging nodes that used to also be second order nodes, we
1603  // might now have an invalid nodal processor_id()
1605 
1606  // delete or renumber nodes if desired
1607  this->prepare_for_use();
1608 }
void set_parent(Elem *p)
Sets the pointer to the element&#39;s parent.
Definition: elem.h:2883
static void set_node_processor_ids(MeshBase &mesh)
This function is called after partitioning to set the processor IDs for the nodes.
Definition: partitioner.C:851
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
libmesh_assert(ctx)
virtual void delete_node(Node *n)=0
Removes the Node n from the mesh.
void regenerate_id_sets()
Clears and regenerates the cached sets of ids.
void prepare_for_use()
Definition: mesh_base.C:742
virtual Elem * insert_elem(Elem *e)=0
Insert elem e to the element array, preserving its id and replacing/deleting any existing element wit...
void copy_boundary_ids(const BoundaryInfo &old_boundary_info, const Elem *const old_elem, const Elem *const new_elem)
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820
virtual dof_id_type max_node_id() const =0
static ElemType first_order_equivalent_type(const ElemType et)
Definition: elem.C:2692
virtual void renumber_nodes_and_elements()=0
After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contigu...
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3000
const RemoteElem * remote_elem
Definition: remote_elem.C:54

◆ all_second_order()

void libMesh::MeshBase::all_second_order ( const bool  full_ordered = true)
inherited

Calls the range-based version of this function with a range consisting of all elements in the mesh.

Definition at line 1535 of file mesh_base.C.

References libMesh::MeshBase::all_second_order_range().

Referenced by AllSecondOrderTest::allSecondOrder(), build_domain(), main(), ExtraIntegersTest::test_helper(), and InfFERadialTest::testRefinement().

1536 {
1537  this->all_second_order_range(this->element_ptr_range(), full_ordered);
1538 }
virtual void all_second_order_range(const SimpleRange< element_iterator > &range, const bool full_ordered=true)=0
Converts a set of this Mesh&#39;s elements defined by range from FIRST order to SECOND order...

◆ all_second_order_range()

void libMesh::UnstructuredMesh::all_second_order_range ( const SimpleRange< element_iterator > &  range,
const bool  full_ordered = true 
)
overridevirtualinherited

Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements.

For example, a mesh consisting of Tet4 will be converted to a mesh with Tet10 etc.

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

Implements libMesh::MeshBase.

Definition at line 1613 of file unstructured_mesh.C.

References libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::reserve_nodes(), and libMesh::Elem::second_order_equivalent_type().

1615 {
1616  LOG_SCOPE("all_second_order_range()", "Mesh");
1617 
1618  /*
1619  * The maximum number of new second order nodes we might be adding,
1620  * for use when picking unique unique_id values later. This variable
1621  * is not used unless unique ids are enabled.
1622  */
1623  unsigned int max_new_nodes_per_elem;
1624 
1625  /*
1626  * For speed-up of the \p add_point() method, we
1627  * can reserve memory. Guess the number of additional
1628  * nodes based on the element spatial dimensions and the
1629  * total number of nodes in the mesh as an upper bound.
1630  */
1631  switch (this->mesh_dimension())
1632  {
1633  case 1:
1634  /*
1635  * in 1D, there can only be order-increase from Edge2
1636  * to Edge3. Something like 1/2 of n_nodes() have
1637  * to be added
1638  */
1639  max_new_nodes_per_elem = 3 - 2;
1640  this->reserve_nodes(static_cast<unsigned int>
1641  (1.5*static_cast<double>(this->n_nodes())));
1642  break;
1643 
1644  case 2:
1645  /*
1646  * in 2D, either refine from Tri3 to Tri6 (double the nodes)
1647  * or from Quad4 to Quad8 (again, double) or Quad9 (2.25 that much)
1648  */
1649  max_new_nodes_per_elem = 9 - 4;
1650  this->reserve_nodes(static_cast<unsigned int>
1651  (2*static_cast<double>(this->n_nodes())));
1652  break;
1653 
1654 
1655  case 3:
1656  /*
1657  * in 3D, either refine from Tet4 to Tet10 (factor = 2.5) up to
1658  * Hex8 to Hex27 (something > 3). Since in 3D there _are_ already
1659  * quite some nodes, and since we do not want to overburden the memory by
1660  * a too conservative guess, use the lower bound
1661  */
1662  max_new_nodes_per_elem = 27 - 8;
1663  this->reserve_nodes(static_cast<unsigned int>
1664  (2.5*static_cast<double>(this->n_nodes())));
1665  break;
1666 
1667  default:
1668  // Hm?
1669  libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
1670  }
1671 
1672  // All the real work is done in the helper function
1673  all_increased_order_range(*this, range, max_new_nodes_per_elem,
1674  [full_ordered](ElemType t) {
1675  return Elem::second_order_equivalent_type(t, full_ordered);
1676  });
1677 }
ElemType
Defines an enum for geometric element types.
virtual void reserve_nodes(const dof_id_type nn)=0
Reserves space for a known number of nodes.
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition: elem.C:2760
unsigned int mesh_dimension() const
Definition: mesh_base.C:324
virtual dof_id_type n_nodes() const =0

◆ allgather()

void libMesh::DistributedMesh::allgather ( )
overridevirtualinherited

Gathers all elements and nodes of the mesh onto every processor.

Reimplemented from libMesh::MeshBase.

Definition at line 1806 of file distributed_mesh.C.

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

1807 {
1808  if (_is_serial)
1809  return;
1810  MeshCommunication().allgather(*this);
1811  _is_serial = true;
1812  _is_serial_on_proc_0 = true;
1813 
1814  // Make sure our caches are up to date and our
1815  // DofObjects are well packed
1816 #ifdef DEBUG
1817  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1818  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1819  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1820  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1821  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1822  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1823 
1824  // If we've disabled renumbering we can't be sure we're contiguous
1825  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1826  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1827 
1828  // Make sure our neighbor links are all fine
1830 
1831  // Make sure our ids and flags are consistent
1834 #endif
1835 }
virtual dof_id_type parallel_n_nodes() const override
virtual void libmesh_assert_valid_parallel_ids() const override
Verify id and processor_id consistency of our elements and nodes containers.
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
virtual dof_id_type n_nodes() const override final
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.
void libmesh_assert_valid_parallel_flags() const
Verify refinement_flag and p_refinement_flag consistency of our elements containers.
friend class MeshCommunication
Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.
Definition: mesh_base.h:2039
virtual dof_id_type parallel_n_elem() const override
dof_id_type parallel_max_node_id() const
virtual dof_id_type max_node_id() const override final
virtual dof_id_type n_elem() const override final
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
A function for verifying that neighbor connectivity is correct (each element is a neighbor of or desc...
Definition: mesh_tools.C:2031
virtual dof_id_type max_elem_id() const override final
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ allow_find_neighbors() [1/2]

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

If false is passed then this mesh will no longer work to find element neighbors when being prepared for use.

Definition at line 1180 of file mesh_base.h.

References libMesh::MeshBase::_skip_find_neighbors.

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

1180 { _skip_find_neighbors = !allow; }
bool _skip_find_neighbors
If this is true then we will skip find_neighbors in prepare_for_use.
Definition: mesh_base.h:1873

◆ allow_find_neighbors() [2/2]

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

◆ allow_remote_element_removal() [1/2]

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

If false is passed in then this mesh will no longer have remote elements deleted when being prepared for use; i.e.

even a DistributedMesh will remain (if it is already) serialized. This may adversely affect performance and memory use.

Definition at line 1189 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

Referenced by AllSecondOrderTest::allCompleteOrder(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allSecondOrder(), AllSecondOrderTest::allSecondOrderDoNothing(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), main(), libMesh::MeshSerializer::MeshSerializer(), PeriodicBCTest::testPeriodicBC(), and libMesh::MeshSerializer::~MeshSerializer().

1189 { _allow_remote_element_removal = allow; }
bool _allow_remote_element_removal
If this is false then even on DistributedMesh remote elements will not be deleted during mesh prepara...
Definition: mesh_base.h:1881

◆ allow_remote_element_removal() [2/2]

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

Definition at line 1190 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::UnstructuredMesh::stitching_helper().

bool _allow_remote_element_removal
If this is false then even on DistributedMesh remote elements will not be deleted during mesh prepara...
Definition: mesh_base.h:1881

◆ allow_renumbering() [1/2]

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

If false is passed in then this mesh will no longer be renumbered when being prepared for use.

This may slightly adversely affect performance during subsequent element access, particularly when using a distributed mesh.

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

Definition at line 1173 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by AllSecondOrderTest::allSecondOrderMixedFixing(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::NameBasedIO::read(), libMesh::GMVIO::read(), WriteVecAndScalar::setupTests(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshGenerationTest::testBuildSphere(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), MeshGenerationTest::tester(), ExtraIntegersTest::testExtraIntegersExodusReading(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testRepartitionThenReinit(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), WriteNodesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), and WriteElemsetData::testWriteImpl().

bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868

◆ allow_renumbering() [2/2]

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

Definition at line 1174 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

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

bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868

◆ assign()

MeshBase & libMesh::DistributedMesh::assign ( MeshBase &&  other_mesh)
overridevirtualinherited

Shim to call the move assignment operator for this class.

Implements libMesh::UnstructuredMesh.

Definition at line 90 of file distributed_mesh.C.

91 {
92  *this = std::move(cast_ref<DistributedMesh&>(other_mesh));
93 
94  return *this;
95 }

◆ cache_elem_data()

void libMesh::MeshBase::cache_elem_data ( )
inherited

Definition at line 1662 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_mesh_subdomains, libMesh::MeshBase::_spatial_dimension, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::MeshBase::mesh_dimension(), and TIMPI::Communicator::set_union().

Referenced by libMesh::MeshBase::cache_elem_dims(), libMesh::MeshBase::prepare_for_use(), and libMesh::MeshBase::set_elem_dimensions().

1663 {
1664  // This requires an inspection on every processor
1665  parallel_object_only();
1666 
1667  // Need to clear _elem_dims first in case all elements of a
1668  // particular dimension have been deleted.
1669  _elem_dims.clear();
1670  _mesh_subdomains.clear();
1671 
1672  for (const auto & elem : this->active_element_ptr_range())
1673  {
1674  _elem_dims.insert(cast_int<unsigned char>(elem->dim()));
1675  _mesh_subdomains.insert(elem->subdomain_id());
1676  }
1677 
1678  if (!this->is_serial())
1679  {
1680  // Some different dimension elements may only live on other processors
1681  this->comm().set_union(_elem_dims);
1682  this->comm().set_union(_mesh_subdomains);
1683  }
1684 
1685  // If the largest element dimension found is larger than the current
1686  // _spatial_dimension, increase _spatial_dimension.
1687  unsigned int max_dim = this->mesh_dimension();
1688  if (max_dim > _spatial_dimension)
1689  _spatial_dimension = cast_int<unsigned char>(max_dim);
1690 
1691  // _spatial_dimension may need to increase from 1->2 or 2->3 if the
1692  // mesh is full of 1D elements but they are not x-aligned, or the
1693  // mesh is full of 2D elements but they are not in the x-y plane.
1694  // If the mesh is x-aligned or x-y planar, we will end up checking
1695  // every node's coordinates and not breaking out of the loop
1696  // early...
1697 #if LIBMESH_DIM > 1
1698  if (_spatial_dimension < 3)
1699  {
1700  for (const auto & node : this->node_ptr_range())
1701  {
1702  // Note: the exact floating point comparison is intentional,
1703  // we don't want to get tripped up by tolerances.
1704  if ((*node)(1) != 0.)
1705  {
1706  _spatial_dimension = 2;
1707 #if LIBMESH_DIM == 2
1708  // If libmesh is compiled in 2D mode, this is the
1709  // largest spatial dimension possible so we can break
1710  // out.
1711  break;
1712 #endif
1713  }
1714 
1715 #if LIBMESH_DIM > 2
1716  if ((*node)(2) != 0.)
1717  {
1718  // Spatial dimension can't get any higher than this, so
1719  // we can break out.
1720  _spatial_dimension = 3;
1721  break;
1722  }
1723 #endif
1724  }
1725  }
1726 #endif // LIBMESH_DIM > 1
1727 }
std::set< subdomain_id_type > _mesh_subdomains
We cache the subdomain ids of the elements present in the mesh.
Definition: mesh_base.h:1900
const Parallel::Communicator & comm() const
unsigned char _spatial_dimension
The "spatial dimension" of the Mesh.
Definition: mesh_base.h:1932
virtual bool is_serial() const
Definition: mesh_base.h:205
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895
unsigned int mesh_dimension() const
Definition: mesh_base.C:324
void set_union(T &data, const unsigned int root_id) const

◆ cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )
inherited

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

Definition at line 1655 of file mesh_base.C.

References libMesh::MeshBase::cache_elem_data().

1656 {
1657  libmesh_deprecated();
1658 
1659  this->cache_elem_data();
1660 }
void cache_elem_data()
Definition: mesh_base.C:1662

◆ change_elemset_code()

void libMesh::MeshBase::change_elemset_code ( dof_id_type  old_code,
dof_id_type  new_code 
)
inherited

Replace elemset code "old_code" with "new_code".

This function loops over all elements and changes the extra integer corresponding to the "elemset_code" label, and updates the _elemset_codes and _elemset_codes_inverse_map members. Does not change the elemset ids of any of the sets.

Definition at line 406 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes, libMesh::MeshBase::_elemset_codes_inverse_map, libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::get_elem_integer_index(), and libMesh::MeshBase::has_elem_integer().

407 {
408  // Look up elemset ids for old_code
409  auto it = _elemset_codes.find(old_code);
410 
411  // If we don't have the old_code, then do nothing. Alternatively, we
412  // could throw an error since trying to change an elemset code you
413  // don't have could indicate there's a problem...
414  if (it == _elemset_codes.end())
415  return;
416 
417  // Make copy of the set of elemset ids. We are not changing these,
418  // only updating the elemset code it corresponds to.
419  elemset_type id_set_copy = *(it->second);
420 
421  // Look up the corresponding entry in the inverse map. Note: we want
422  // the iterator because we are going to remove it.
423  auto inverse_it = _elemset_codes_inverse_map.find(id_set_copy);
424  libmesh_error_msg_if(inverse_it == _elemset_codes_inverse_map.end(),
425  "Expected _elemset_codes_inverse_map entry for elemset code " << old_code);
426 
427  // Erase entry from inverse map
428  _elemset_codes_inverse_map.erase(inverse_it);
429 
430  // Erase entry from forward map
431  _elemset_codes.erase(it);
432 
433  // Add new code with original set of ids.
434  this->add_elemset_code(new_code, id_set_copy);
435 
436  // We can't update any actual elemset codes if there is no extra integer defined for it.
437  if (!this->has_elem_integer("elemset_code"))
438  return;
439 
440  // Get index of elemset_code extra integer
441  unsigned int elemset_index = this->get_elem_integer_index("elemset_code");
442 
443  // Loop over all elems and update code
444  for (auto & elem : this->element_ptr_range())
445  {
446  dof_id_type elemset_code =
447  elem->get_extra_integer(elemset_index);
448 
449  if (elemset_code == old_code)
450  elem->set_extra_integer(elemset_index, new_code);
451  }
452 }
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924
void add_elemset_code(dof_id_type code, MeshBase::elemset_type id_set)
Tabulate a user-defined "code" for elements which belong to the element sets specified in id_set...
Definition: mesh_base.C:350
bool has_elem_integer(std::string_view name) const
Definition: mesh_base.C:590
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
unsigned int get_elem_integer_index(std::string_view name) const
Definition: mesh_base.C:578
std::set< elemset_id_type > elemset_type
Typedef for the "set" container used to store elemset ids.
Definition: mesh_base.h:297
uint8_t dof_id_type
Definition: id_types.h:67

◆ change_elemset_id()

void libMesh::MeshBase::change_elemset_id ( elemset_id_type  old_id,
elemset_id_type  new_id 
)
inherited

Replace elemset id "old_id" with "new_id".

Does not change any of the elemset codes, so does not need to loop over the elements themselves.

Definition at line 454 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids, libMesh::MeshBase::_elemset_codes, and libMesh::MeshBase::_elemset_codes_inverse_map.

455 {
456  // Early return if we don't have old_id
457  if (!_all_elemset_ids.count(old_id))
458  return;
459 
460  // Throw an error if the new_id is already used
461  libmesh_error_msg_if(_all_elemset_ids.count(new_id),
462  "Cannot change elemset id " << old_id <<
463  " to " << new_id << ", " << new_id << " already exists.");
464 
465  // We will build up a new version of the inverse map so we can iterate over
466  // the current one without invalidating anything.
467  std::map<MeshBase::elemset_type, dof_id_type> new_elemset_codes_inverse_map;
468  for (const auto & [id_set, elemset_code] : _elemset_codes_inverse_map)
469  {
470  auto id_set_copy = id_set;
471  if (id_set_copy.count(old_id))
472  {
473  // Remove old_id, insert new_id
474  id_set_copy.erase(old_id);
475  id_set_copy.insert(new_id);
476  }
477 
478  // Store in new version of map
479  new_elemset_codes_inverse_map.emplace(id_set_copy, elemset_code);
480  }
481 
482  // Swap existing map with newly-built one
483  _elemset_codes_inverse_map.swap(new_elemset_codes_inverse_map);
484 
485  // Reconstruct _elemset_codes map
486  _elemset_codes.clear();
487  for (const auto & [id_set, elemset_code] : _elemset_codes_inverse_map)
488  _elemset_codes.emplace(elemset_code, &id_set);
489 
490  // Update _all_elemset_ids
491  _all_elemset_ids.erase(old_id);
492  _all_elemset_ids.insert(new_id);
493 }
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
MeshBase::elemset_type _all_elemset_ids
Definition: mesh_base.h:1926

◆ clear()

void libMesh::DistributedMesh::clear ( )
overridevirtualinherited

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 990 of file distributed_mesh.C.

References libMesh::DistributedMesh::_deleted_coarse_elements, libMesh::DistributedMesh::_is_serial, libMesh::DistributedMesh::_is_serial_on_proc_0, libMesh::DistributedMesh::_max_node_id, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_next_free_local_node_id, libMesh::DistributedMesh::_next_free_unpartitioned_node_id, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::clear(), libMesh::DofMap::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

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

991 {
992  // Call parent clear function
993  MeshBase::clear();
994 
995  // Clear our elements and nodes
996  // There is no need to remove them from
997  // the BoundaryInfo data structure since we
998  // already cleared it.
1000 
1001  for (auto & node : _nodes)
1002  delete node;
1003 
1004  _nodes.clear();
1005 
1006  // We're no longer distributed if we were before
1007  _is_serial = true;
1008  _is_serial_on_proc_0 = true;
1009 
1010  // We deleted a ton of coarse elements, but their nodes got deleted too so
1011  // all is copacetic.
1012  _deleted_coarse_elements = false;
1013 
1014  // Correct our caches
1015  _n_nodes = 0;
1016  _max_node_id = 0;
1019 }
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
dof_id_type _next_free_local_node_id
Guaranteed globally unused IDs for use when adding new nodes or elements.
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
processor_id_type n_processors() const
virtual void clear_elems() override
Clear internal Elem data.
void clear()
Free all new memory associated with the object, but restore its original state, with the mesh pointer...
Definition: dof_map.C:850
virtual void clear()
Deletes all the element and node data that is currently stored.
Definition: mesh_base.C:862
dof_id_type _next_free_unpartitioned_node_id
processor_id_type processor_id() const
bool _deleted_coarse_elements
A boolean remembering whether we&#39;ve recently deleted top-level elements or not.

◆ clear_elems()

void libMesh::DistributedMesh::clear_elems ( )
overridevirtualinherited

Clear internal Elem data.

Implements libMesh::MeshBase.

Definition at line 1023 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_next_free_local_elem_id, libMesh::DistributedMesh::_next_free_unpartitioned_elem_id, libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

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

1024 {
1025  for (auto & elem : _elements)
1026  delete elem;
1027 
1028  _elements.clear();
1029 
1030  // Correct our caches
1031  _n_elem = 0;
1032  _max_elem_id = 0;
1035 }
processor_id_type n_processors() const
dofobject_container< Elem > _elements
The elements in the mesh.
dof_id_type _next_free_unpartitioned_elem_id
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id

◆ clear_extra_ghost_elems() [1/2]

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

Clears extra ghost elements.

Definition at line 251 of file distributed_mesh.h.

References libMesh::DistributedMesh::_extra_ghost_elems.

251 { _extra_ghost_elems.clear(); }
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...

◆ clear_extra_ghost_elems() [2/2]

void libMesh::DistributedMesh::clear_extra_ghost_elems ( const std::set< Elem *> &  extra_ghost_elems)
virtualinherited

Clears specified extra ghost elements.

Definition at line 1797 of file distributed_mesh.C.

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

1798 {
1799  std::set<Elem *> tmp;
1800  std::set_difference(_extra_ghost_elems.begin(), _extra_ghost_elems.end(),
1801  extra_ghost_elems.begin(), extra_ghost_elems.end(),
1802  std::inserter(tmp, tmp.begin()));
1803  _extra_ghost_elems = tmp;
1804 }
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...
const std::set< Elem * > & extra_ghost_elems() const
Const accessor to the ghosted elements.

◆ clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )
inherited

Releases the current PointLocator object.

Definition at line 1598 of file mesh_base.C.

References libMesh::MeshBase::_point_locator.

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

1599 {
1600  _point_locator.reset(nullptr);
1601 }
std::unique_ptr< PointLocatorBase > _point_locator
A PointLocator class for this mesh.
Definition: mesh_base.h:1829

◆ clone()

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

Virtual copy-constructor, creates a copy of this mesh.

Reimplemented from libMesh::DistributedMesh.

Definition at line 44 of file parallel_mesh.h.

45  { return std::make_unique<ParallelMesh>(*this); }

◆ comm()

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

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), 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::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), 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::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::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_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), 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_bcids_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::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), 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::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), 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::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

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

◆ contract()

bool libMesh::UnstructuredMesh::contract ( )
overridevirtualinherited

Delete subactive (i.e.

children of coarsened) elements. This removes all elements descended from currently active elements in the mesh.

Implements libMesh::MeshBase.

Definition at line 1403 of file unstructured_mesh.C.

References libMesh::as_range(), libMesh::MeshBase::clear_point_locator(), libMesh::MeshBase::delete_elem(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::libmesh_assert(), and libMesh::MeshBase::renumber_nodes_and_elements().

1404 {
1405  LOG_SCOPE ("contract()", "Mesh");
1406 
1407  // Flag indicating if this call actually changes the mesh
1408  bool mesh_changed = false;
1409 
1410 #ifdef DEBUG
1411  for (const auto & elem : this->element_ptr_range())
1412  libmesh_assert(elem->active() || elem->subactive() || elem->ancestor());
1413 #endif
1414 
1415  // Loop over the elements.
1416  for (auto & elem : this->element_ptr_range())
1417  {
1418  // Delete all the subactive ones
1419  if (elem->subactive())
1420  {
1421  // No level-0 element should be subactive.
1422  // Note that we CAN'T test elem->level(), as that
1423  // touches elem->parent()->dim(), and elem->parent()
1424  // might have already been deleted!
1425  libmesh_assert(elem->parent());
1426 
1427  // Delete the element
1428  // This just sets a pointer to nullptr, and doesn't
1429  // invalidate any iterators
1430  this->delete_elem(elem);
1431 
1432  // the mesh has certainly changed
1433  mesh_changed = true;
1434  }
1435  else
1436  {
1437  // Compress all the active ones
1438  if (elem->active())
1439  elem->contract();
1440  else
1441  libmesh_assert (elem->ancestor());
1442  }
1443  }
1444 
1445  // Strip any newly-created nullptr voids out of the element array
1447 
1448  // FIXME: Need to understand why deleting subactive children
1449  // invalidates the point locator. For now we will clear it explicitly
1450  this->clear_point_locator();
1451 
1452  // Allow our GhostingFunctor objects to reinit if necessary.
1453  for (auto & gf : as_range(this->ghosting_functors_begin(),
1454  this->ghosting_functors_end()))
1455  {
1456  libmesh_assert(gf);
1457  gf->mesh_reinit();
1458  }
1459 
1460  return mesh_changed;
1461 }
virtual void delete_elem(Elem *e)=0
Removes element e from the mesh.
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Helper function that allows us to treat a homogenous pair as a range.
Definition: simple_range.h:57
void clear_point_locator()
Releases the current PointLocator object.
Definition: mesh_base.C:1598
libmesh_assert(ctx)
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Beginning of range of ghosting functors.
Definition: mesh_base.h:1268
virtual void renumber_nodes_and_elements()=0
After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contigu...
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
End of range of ghosting functors.
Definition: mesh_base.h:1274

◆ copy_constraint_rows() [1/2]

void libMesh::MeshBase::copy_constraint_rows ( const MeshBase other_mesh)
inherited

Copy the constraints from the other mesh to this mesh.

Definition at line 1938 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::get_constraint_rows(), and libMesh::MeshBase::node_ptr().

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::ReplicatedMesh::ReplicatedMesh(), ConstraintOperatorTest::test1DCoarseningNewNodes(), and ConstraintOperatorTest::test1DCoarseningOperator().

1939 {
1940  _constraint_rows.clear();
1941 
1942  const auto & other_constraint_rows = other_mesh.get_constraint_rows();
1943  for (const auto & [other_node, other_node_constraints] : other_constraint_rows)
1944  {
1945  const Node * const our_node = this->node_ptr(other_node->id());
1946  constraint_rows_mapped_type our_node_constraints;
1947  for (const auto & [other_inner_key_pair, constraint_value] : other_node_constraints)
1948  {
1949  const auto & [other_elem, local_node_id] = other_inner_key_pair;
1950  const Elem * const our_elem = this->elem_ptr(other_elem->id());
1951  our_node_constraints.emplace_back(std::make_pair(our_elem, local_node_id), constraint_value);
1952  }
1953  _constraint_rows[our_node] = std::move(our_node_constraints);
1954  }
1955 }
std::vector< std::pair< std::pair< const Elem *, unsigned int >, Real > > constraint_rows_mapped_type
Definition: mesh_base.h:1674
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ copy_constraint_rows() [2/2]

template<typename T >
void libMesh::MeshBase::copy_constraint_rows ( const SparseMatrix< T > &  constraint_operator)
inherited

Copy the constraints from the given matrix to this mesh.

The constraint_operator should be an mxn matrix, where m == this->n_nodes() and the operator indexing matches the current node indexing. This may require users to disable mesh renumbering in between loading a mesh file and loading a constraint matrix which matches it.

If any "constraint" rows in the matrix are unit vectors, the node corresponding to that row index will be left unconstrained, and will be used to constrain any other nodes which have a non-zero in the column index of that unit vector.

For each matrix column index which does not correspond to an existing node, a new NodeElem will be added to the mesh on which to store the new unconstrained degree(s) of freedom.

T for the constraint_operator in this function should be Real or Number ... and the data should be Real - we just allow complex T for the sake of subclasses which have to be configured and compiled with only one runtime option.

Definition at line 1960 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), TIMPI::Communicator::allgather(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_ptr(), libMesh::SparseMatrix< T >::get_row(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::libmesh_real(), libMesh::SparseMatrix< T >::m(), libMesh::make_range(), libMesh::SparseMatrix< T >::n(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::node_ref(), libMesh::NODEELEM, libMesh::DofObject::processor_id(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), and TIMPI::Communicator::set_union().

1961 {
1962  this->_constraint_rows.clear();
1963 
1964  // We're not going to support doing this distributed yet; it'd be
1965  // pointless unless we temporarily had a linear partitioning to
1966  // better match the constraint operator.
1967  MeshSerializer serialize(*this);
1968 
1969  // Our current mesh should already reflect the desired assembly space
1970  libmesh_error_msg_if(this->n_nodes() != constraint_operator.m(),
1971  "Constraint operator matrix does not match this mesh");
1972 
1973  // First, find what new unconstrained DoFs we need to add. We can't
1974  // iterate over columns in a SparseMatrix, so we'll iterate over
1975  // rows and keep track of columns.
1976 
1977  // If we have nodes that will work unconstrained, keep track of
1978  // their node ids and corresponding column indices.
1979  // existing_unconstrained_nodes[column_id] = node_id
1980  std::map<dof_id_type, dof_id_type> existing_unconstrained_columns;
1981  std::set<dof_id_type> existing_unconstrained_nodes;
1982 
1983  // In case we need new nodes, keep track of their columns.
1984  // columns[j][k] will be the kth row index and value of column j
1985  typedef
1986  std::unordered_map<dof_id_type,
1987  std::vector<std::pair<dof_id_type, Real>>>
1988  columns_type;
1989  columns_type columns(constraint_operator.n());
1990 
1991  // Work in parallel, though we'll have to sync shortly
1992  for (auto i : make_range(constraint_operator.row_start(),
1993  constraint_operator.row_stop()))
1994  {
1995  std::vector<numeric_index_type> indices;
1996  std::vector<T> values;
1997 
1998  constraint_operator.get_row(i, indices, values);
1999  libmesh_assert_equal_to(indices.size(), values.size());
2000 
2001  if (indices.size() == 1 &&
2002  values[0] == T(1))
2003  {
2004  existing_unconstrained_nodes.insert(i);
2005  existing_unconstrained_columns.emplace(indices[0],i);
2006  }
2007  else
2008  for (auto jj : index_range(indices))
2009  {
2010  const auto j = indices[jj];
2011  const Real coef = libmesh_real(values[jj]);
2012  libmesh_assert_equal_to(coef, values[jj]);
2013  columns[j].emplace_back(i, coef);
2014  }
2015  }
2016 
2017  // Merge data from different processors' slabs of the matrix
2018  this->comm().set_union(existing_unconstrained_nodes);
2019  this->comm().set_union(existing_unconstrained_columns);
2020 
2021  std::vector<columns_type> all_columns;
2022  this->comm().allgather(columns, all_columns);
2023 
2024  columns.clear();
2025  for (auto p : index_range(all_columns))
2026  for (auto & [j, subcol] : all_columns[p])
2027  for (auto [i, v] : subcol)
2028  columns[j].emplace_back(i,v);
2029 
2030  // Keep track of elements on which unconstrained nodes exist, and
2031  // their local node indices.
2032  // node_to_elem_ptrs[node] = [elem_id, local_node_num]
2033  std::unordered_map<const Node *, std::pair<dof_id_type, unsigned int>> node_to_elem_ptrs;
2034 
2035  // Find elements attached to any existing nodes that will stay
2036  // unconstrained
2037  for (const Elem * elem : this->element_ptr_range())
2038  for (auto n : make_range(elem->n_nodes()))
2039  {
2040  const Node * node = elem->node_ptr(n);
2041  if (existing_unconstrained_nodes.count(node->id()))
2042  node_to_elem_ptrs.emplace(node, std::make_pair(elem->id(), n));
2043  }
2044 
2045  for (auto j : make_range(constraint_operator.n()))
2046  {
2047  // If we already have a good node for this then we're done
2048  if (existing_unconstrained_columns.find(j) !=
2049  existing_unconstrained_columns.end())
2050  continue;
2051 
2052  // Get a half-decent spot to place a new NodeElem for
2053  // unconstrained DoF(s) here. Getting a *fully*-decent spot
2054  // would require finding a Moore-Penrose pseudoinverse, and I'm
2055  // not going to do that, but scaling a transpose will at least
2056  // get us a little uniqueness to make visualization reasonable.
2057  Point newpt;
2058  Real total_scaling = 0;
2059 
2060  // We'll get a decent initial pid choice here too, if only to
2061  // aid in later repartitioning.
2062  std::map<processor_id_type, int> pids;
2063 
2064  auto & column = columns[j];
2065  for (auto [i, r] : column)
2066  {
2067  Node & constrained_node = this->node_ref(i);
2068  const Point constrained_pt = constrained_node;
2069  newpt += r*constrained_pt;
2070  total_scaling += r;
2071  ++pids[constrained_node.processor_id()];
2072  }
2073  newpt /= total_scaling;
2074 
2075  Node *n = this->add_point(newpt);
2076  std::unique_ptr<Elem> elem = Elem::build(NODEELEM);
2077  elem->set_node(0) = n;
2078 
2079  Elem * added_elem = this->add_elem(std::move(elem));
2080  node_to_elem_ptrs.emplace(n, std::make_pair(added_elem->id(), 0));
2081  existing_unconstrained_columns.emplace(j,n->id());
2082 
2083  // Repartition the new objects *after* adding them, so a
2084  // DistributedMesh doesn't get confused and think you're not
2085  // adding them on all processors at once.
2086  int n_pids = 0;
2087  for (auto [pid, count] : pids)
2088  if (count >= n_pids)
2089  {
2090  n_pids = count;
2091  added_elem->processor_id() = pid;
2092  n->processor_id() = pid;
2093  }
2094  }
2095 
2096  // Calculate constraint rows in an indexed form that's easy for us
2097  // to allgather
2098  std::unordered_map<dof_id_type,
2099  std::vector<std::pair<std::pair<dof_id_type, unsigned int>,Real>>>
2100  indexed_constraint_rows;
2101 
2102  for (auto i : make_range(constraint_operator.row_start(),
2103  constraint_operator.row_stop()))
2104  {
2105  if (existing_unconstrained_nodes.count(i))
2106  continue;
2107 
2108  std::vector<numeric_index_type> indices;
2109  std::vector<T> values;
2110 
2111  constraint_operator.get_row(i, indices, values);
2112 
2113  std::vector<std::pair<std::pair<dof_id_type, unsigned int>, Real>> constraint_row;
2114 
2115  for (auto jj : index_range(indices))
2116  {
2117  const dof_id_type node_id =
2118  existing_unconstrained_columns[indices[jj]];
2119 
2120  Node & constraining_node = this->node_ref(node_id);
2121 
2122  libmesh_assert(node_to_elem_ptrs.count(&constraining_node));
2123 
2124  auto p = node_to_elem_ptrs[&constraining_node];
2125 
2126  const Real coef = libmesh_real(values[jj]);
2127  libmesh_assert_equal_to(coef, values[jj]);
2128  constraint_row.emplace_back(std::make_pair(p, coef));
2129  }
2130 
2131  indexed_constraint_rows.emplace(i, std::move(constraint_row));
2132  }
2133 
2134  this->comm().set_union(indexed_constraint_rows);
2135 
2136  // Add constraint rows as mesh constraint rows
2137  for (auto & [node_id, indexed_row] : indexed_constraint_rows)
2138  {
2139  Node * constrained_node = this->node_ptr(node_id);
2140 
2141  constraint_rows_mapped_type constraint_row;
2142 
2143  for (auto [p, coef] : indexed_row)
2144  {
2145  const Elem * elem = this->elem_ptr(p.first);
2146  constraint_row.emplace_back
2147  (std::make_pair(std::make_pair(elem, p.second), coef));
2148  }
2149 
2150  this->_constraint_rows.emplace(constrained_node,
2151  std::move(constraint_row));
2152  }
2153 }
T libmesh_real(T a)
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
std::vector< std::pair< std::pair< const Elem *, unsigned int >, Real > > constraint_rows_mapped_type
Definition: mesh_base.h:1674
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
const Parallel::Communicator & comm() const
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
Add a new Node at Point p to the end of the vertex array, with processor_id procid.
virtual Elem * add_elem(Elem *e)=0
Add elem e to the end of the element array.
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
libmesh_assert(ctx)
virtual const Elem * elem_ptr(const dof_id_type i) const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
virtual const Node & node_ref(const dof_id_type i) const
Definition: mesh_base.h:575
virtual const Node * node_ptr(const dof_id_type i) const =0
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
virtual dof_id_type n_nodes() const =0
uint8_t dof_id_type
Definition: id_types.h:67
void set_union(T &data, const unsigned int root_id) const

◆ copy_nodes_and_elements()

void libMesh::UnstructuredMesh::copy_nodes_and_elements ( const MeshBase other_mesh,
const bool  skip_find_neighbors = false,
dof_id_type  element_id_offset = 0,
dof_id_type  node_id_offset = 0,
unique_id_type  unique_id_offset = 0,
std::unordered_map< subdomain_id_type, subdomain_id_type > *  id_remapping = nullptr 
)
virtualinherited

Deep copy of nodes and elements from another mesh object (used by subclass copy constructors and by mesh merging operations)

This will not copy most "high level" data in the mesh; that is done separately by constructors. An exception is that, if the other_mesh has element or node extra_integer data, any names for that data which do not already exist on this mesh are added so that all such data can be copied.

If an id_remapping map is provided, then element subdomain ids in other_mesh will be converted using it before adding them to this mesh.

Definition at line 645 of file unstructured_mesh.C.

References libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_n_parts, libMesh::MeshBase::_node_integer_names, libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::Elem::build(), libMesh::MeshBase::elem_ptr(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::Elem::neighbor_ptr(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::parallel_max_unique_id(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::MeshBase::set_next_unique_id(), and libMesh::MeshBase::skip_partitioning().

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

656 {
657  LOG_SCOPE("copy_nodes_and_elements()", "UnstructuredMesh");
658 
659  std::pair<std::vector<unsigned int>, std::vector<unsigned int>>
660  extra_int_maps = this->merge_extra_integer_names(other_mesh);
661 
662  const unsigned int n_old_node_ints = extra_int_maps.second.size(),
663  n_new_node_ints = _node_integer_names.size(),
664  n_old_elem_ints = extra_int_maps.first.size(),
665  n_new_elem_ints = _elem_integer_names.size();
666 
667  // If we are partitioned into fewer parts than the incoming mesh,
668  // then we need to "wrap" the other Mesh's processor ids to fit
669  // within our range. This can happen, for example, while stitching
670  // meshes with small numbers of elements in parallel...
671  bool wrap_proc_ids = (this->n_partitions() <
672  other_mesh.n_partitions());
673 
674  // We're assuming the other mesh has proper element number ordering,
675  // so that we add parents before their children, and that the other
676  // mesh is consistently partitioned.
677 #ifdef DEBUG
679  MeshTools::libmesh_assert_valid_procids<Node>(other_mesh);
680 #endif
681 
682  //Copy in Nodes
683  {
684  //Preallocate Memory if necessary
685  this->reserve_nodes(other_mesh.n_nodes());
686 
687  for (const auto & oldn : other_mesh.node_ptr_range())
688  {
689  processor_id_type added_pid = cast_int<processor_id_type>
690  (wrap_proc_ids ? oldn->processor_id() % _n_parts : oldn->processor_id());
691 
692  // Add new nodes in old node Point locations
693  Node * newn =
694  this->add_point(*oldn,
695  oldn->id() + node_id_offset,
696  added_pid);
697 
698  newn->add_extra_integers(n_new_node_ints);
699  for (unsigned int i = 0; i != n_old_node_ints; ++i)
700  newn->set_extra_integer(extra_int_maps.second[i],
701  oldn->get_extra_integer(i));
702 
703 #ifdef LIBMESH_ENABLE_UNIQUE_ID
704  newn->set_unique_id(oldn->unique_id() + unique_id_offset);
705 #endif
706  }
707  }
708 
709  //Copy in Elements
710  {
711  //Preallocate Memory if necessary
712  this->reserve_elem(other_mesh.n_elem());
713 
714  // Declare a map linking old and new elements, needed to copy the neighbor lists
715  typedef std::unordered_map<const Elem *, Elem *> map_type;
716  map_type old_elems_to_new_elems, ip_map;
717 
718  // Loop over the elements
719  for (const auto & old : other_mesh.element_ptr_range())
720  {
721  // Build a new element
722  Elem * newparent = old->parent() ?
723  this->elem_ptr(old->parent()->id() + element_id_offset) :
724  nullptr;
725  auto el = Elem::build(old->type(), newparent);
726 
727  subdomain_id_type sbd_id = old->subdomain_id();
728  if (id_remapping)
729  {
730  auto remapping_it = id_remapping->find(sbd_id);
731  if (remapping_it != id_remapping->end())
732  sbd_id = remapping_it->second;
733  }
734  el->subdomain_id() = sbd_id;
735 
736  // Hold off on trying to set the interior parent because we may actually
737  // add lower dimensional elements before their interior parents
738  if (el->dim() < other_mesh.mesh_dimension() && old->interior_parent())
739  ip_map[old] = el.get();
740 
741 #ifdef LIBMESH_ENABLE_AMR
742  if (old->has_children())
743  for (unsigned int c = 0, nc = old->n_children(); c != nc; ++c)
744  if (old->child_ptr(c) == remote_elem)
745  el->add_child(const_cast<RemoteElem *>(remote_elem), c);
746 
747  //Create the parent's child pointers if necessary
748  if (newparent)
749  {
750  unsigned int oldc = old->parent()->which_child_am_i(old);
751  newparent->add_child(el.get(), oldc);
752  }
753 
754  // Copy the refinement flags
755  el->set_refinement_flag(old->refinement_flag());
756 
757  // Use hack_p_level since we may not have sibling elements
758  // added yet
759  el->hack_p_level(old->p_level());
760 
761  el->set_p_refinement_flag(old->p_refinement_flag());
762 #endif // #ifdef LIBMESH_ENABLE_AMR
763 
764  //Assign all the nodes
765  for (auto i : el->node_index_range())
766  el->set_node(i) =
767  this->node_ptr(old->node_id(i) + node_id_offset);
768 
769  // And start it off with the same processor id (mod _n_parts).
770  el->processor_id() = cast_int<processor_id_type>
771  (wrap_proc_ids ? old->processor_id() % _n_parts : old->processor_id());
772 
773  // Give it the same element and unique ids
774  el->set_id(old->id() + element_id_offset);
775 
776  el->add_extra_integers(n_new_elem_ints);
777  for (unsigned int i = 0; i != n_old_elem_ints; ++i)
778  el->set_extra_integer(extra_int_maps.first[i],
779  old->get_extra_integer(i));
780 
781 #ifdef LIBMESH_ENABLE_UNIQUE_ID
782  el->set_unique_id(old->unique_id() + unique_id_offset);
783 #endif
784 
785  el->set_mapping_type(old->mapping_type());
786  el->set_mapping_data(old->mapping_data());
787 
788  //Hold onto it
789  if (!skip_find_neighbors)
790  {
791  for (auto s : old->side_index_range())
792  if (old->neighbor_ptr(s) == remote_elem)
793  el->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
794  this->add_elem(std::move(el));
795  }
796  else
797  {
798  Elem * new_el = this->add_elem(std::move(el));
799  old_elems_to_new_elems[old] = new_el;
800  }
801  }
802 
803  for (auto & elem_pair : ip_map)
804  elem_pair.second->set_interior_parent(
805  this->elem_ptr(elem_pair.first->interior_parent()->id() + element_id_offset));
806 
807  // Loop (again) over the elements to fill in the neighbors
808  if (skip_find_neighbors)
809  {
810  old_elems_to_new_elems[remote_elem] = const_cast<RemoteElem*>(remote_elem);
811 
812  for (const auto & old_elem : other_mesh.element_ptr_range())
813  {
814  Elem * new_elem = old_elems_to_new_elems[old_elem];
815  for (auto s : old_elem->side_index_range())
816  {
817  const Elem * old_neighbor = old_elem->neighbor_ptr(s);
818  Elem * new_neighbor = old_elems_to_new_elems[old_neighbor];
819  new_elem->set_neighbor(s, new_neighbor);
820  }
821  }
822  }
823  }
824 
825 #ifdef LIBMESH_ENABLE_UNIQUE_ID
826  // We set the unique ids of nodes after adding them to the mesh such that our value of
827  // _next_unique_id may be wrong. So we amend that here
828  this->set_next_unique_id(other_mesh.parallel_max_unique_id() + unique_id_offset + 1);
829 #endif
830 
831  //Finally prepare the new Mesh for use. Keep the same numbering and
832  //partitioning for now.
833  this->allow_renumbering(false);
834  this->allow_remote_element_removal(false);
835  this->allow_find_neighbors(!skip_find_neighbors);
836 
837  // We should generally be able to skip *all* partitioning here
838  // because we're only adding one already-consistent mesh to another.
839  this->skip_partitioning(true);
840 
841  this->prepare_for_use();
842 
843  //But in the long term, use the same renumbering and partitioning
844  //policies as our source mesh.
845  this->allow_find_neighbors(other_mesh.allow_find_neighbors());
846  this->allow_renumbering(other_mesh.allow_renumbering());
848  this->skip_partitioning(other_mesh.skip_partitioning());
849 }
virtual void reserve_nodes(const dof_id_type nn)=0
Reserves space for a known number of nodes.
const Elem * parent() const
Definition: elem.h:2867
In parallel meshes where a ghost element has neighbors which do not exist on the local processor...
Definition: remote_elem.h:59
A Node is like a Point, but with more information.
Definition: node.h:52
virtual unique_id_type parallel_max_unique_id() const =0
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
void allow_renumbering(bool allow)
If false is passed in then this mesh will no longer be renumbered when being prepared for use...
Definition: mesh_base.h:1173
void skip_partitioning(bool skip)
If true is passed in then nothing on this mesh will be (re)partitioned.
Definition: mesh_base.h:1231
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
void add_child(Elem *elem)
Adds a child pointer to the array of children of this element.
Definition: elem.C:1668
virtual void set_next_unique_id(unique_id_type id)=0
Sets the next available unique id to be used.
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
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
Add a new Node at Point p to the end of the vertex array, with processor_id procid.
void set_interior_parent(Elem *p)
Sets the pointer to the element&#39;s interior_parent.
Definition: elem.C:1056
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802
uint8_t processor_id_type
void allow_remote_element_removal(bool allow)
If false is passed in then this mesh will no longer have remote elements deleted when being prepared ...
Definition: mesh_base.h:1189
virtual Elem * add_elem(Elem *e)=0
Add elem e to the end of the element array.
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
bool allow_find_neighbors() const
Definition: mesh_base.h:1181
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > merge_extra_integer_names(const MeshBase &other)
Merge extra-integer arrays from an other mesh.
Definition: mesh_base.C:1861
void libmesh_assert_valid_amr_elem_ids(const MeshBase &mesh)
A function for verifying that ids of elements are correctly sorted for AMR (parents have lower ids th...
Definition: mesh_tools.C:1193
void allow_find_neighbors(bool allow)
If false is passed then this mesh will no longer work to find element neighbors when being prepared f...
Definition: mesh_base.h:1180
bool allow_remote_element_removal() const
Definition: mesh_base.h:1190
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition: elem.h:2427
void prepare_for_use()
Definition: mesh_base.C:742
bool skip_partitioning() const
Definition: mesh_base.h:1233
unsigned int n_partitions() const
Definition: mesh_base.h:1322
virtual const Elem * elem_ptr(const dof_id_type i) const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2407
void add_extra_integers(const unsigned int n_integers)
Assigns a set of extra integers to this DofObject.
Definition: dof_object.C:490
unsigned int mesh_dimension() const
Definition: mesh_base.C:324
bool allow_renumbering() const
Definition: mesh_base.h:1174
virtual dof_id_type n_elem() const =0
virtual const Node * node_ptr(const dof_id_type i) const =0
processor_id_type processor_id() const
Definition: dof_object.h:898
virtual void reserve_elem(const dof_id_type ne)=0
Reserves space for a known number of elements.
virtual dof_id_type n_nodes() const =0
const RemoteElem * remote_elem
Definition: remote_elem.C:54

◆ create_pid_mesh()

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

Generates a new mesh containing all the elements which are assigned to processor pid.

This mesh is written to the pid_mesh reference which you must create and pass to the function.

Definition at line 1275 of file unstructured_mesh.C.

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

1277 {
1278 
1279  // Issue a warning if the number the number of processors
1280  // currently available is less that that requested for
1281  // partitioning. This is not necessarily an error since
1282  // you may run on one processor and still partition the
1283  // mesh into several partitions.
1284 #ifdef DEBUG
1285  if (this->n_processors() < pid)
1286  {
1287  libMesh::out << "WARNING: You are creating a "
1288  << "mesh for a processor id (="
1289  << pid
1290  << ") greater than "
1291  << "the number of processors available for "
1292  << "the calculation. (="
1293  << this->n_processors()
1294  << ")."
1295  << std::endl;
1296  }
1297 #endif
1298 
1299  this->create_submesh (pid_mesh,
1300  this->active_pid_elements_begin(pid),
1301  this->active_pid_elements_end(pid));
1302 }
processor_id_type n_processors() const
OStreamProxy out
void create_submesh(UnstructuredMesh &new_mesh, const 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 a...

◆ create_submesh()

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

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

Definition at line 1310 of file unstructured_mesh.C.

References libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::as_range(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_extra_integer(), libMesh::Elem::set_node(), and libMesh::DofObject::set_unique_id().

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

1313 {
1314  // Just in case the subdomain_mesh already has some information
1315  // in it, get rid of it.
1316  new_mesh.clear();
1317 
1318  // If we're not serial, our submesh isn't either.
1319  // There are no remote elements to delete on an empty mesh, but
1320  // calling the method to do so marks the mesh as parallel.
1321  if (!this->is_serial())
1322  new_mesh.delete_remote_elements();
1323 
1324  // Fail if (*this == new_mesh), we cannot create a submesh inside ourself!
1325  // This may happen if the user accidentally passes the original mesh into
1326  // this function! We will check this by making sure we did not just
1327  // clear ourself.
1328  libmesh_assert_not_equal_to (this->n_nodes(), 0);
1329  libmesh_assert_not_equal_to (this->n_elem(), 0);
1330 
1331  // Container to catch boundary IDs handed back by BoundaryInfo
1332  std::vector<boundary_id_type> bc_ids;
1333 
1334  // Put any extra integers on the new mesh too
1335  new_mesh.merge_extra_integer_names(*this);
1336  const unsigned int n_node_ints = _node_integer_names.size(),
1337  n_elem_ints = _elem_integer_names.size();
1338 
1339  for (const auto & old_elem : as_range(it, it_end))
1340  {
1341  // Add an equivalent element type to the new_mesh.
1342  // Copy ids for this element.
1343  auto uelem = Elem::build(old_elem->type());
1344  uelem->set_id() = old_elem->id();
1345 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1346  uelem->set_unique_id(old_elem->unique_id());
1347 #endif
1348  uelem->subdomain_id() = old_elem->subdomain_id();
1349  uelem->processor_id() = old_elem->processor_id();
1350 
1351  uelem->add_extra_integers(n_elem_ints);
1352  for (unsigned int i = 0; i != n_elem_ints; ++i)
1353  uelem->set_extra_integer(i, old_elem->get_extra_integer(i));
1354 
1355  uelem->set_mapping_type(old_elem->mapping_type());
1356  uelem->set_mapping_data(old_elem->mapping_data());
1357 
1358  Elem * new_elem = new_mesh.add_elem(std::move(uelem));
1359 
1360  libmesh_assert(new_elem);
1361 
1362  // Loop over the nodes on this element.
1363  for (auto n : old_elem->node_index_range())
1364  {
1365  const dof_id_type this_node_id = old_elem->node_id(n);
1366 
1367  // Add this node to the new mesh if it's not there already
1368  if (!new_mesh.query_node_ptr(this_node_id))
1369  {
1370  Node * newn =
1371  new_mesh.add_point (old_elem->point(n),
1372  this_node_id,
1373  old_elem->node_ptr(n)->processor_id());
1374 
1375  newn->add_extra_integers(n_node_ints);
1376  for (unsigned int i = 0; i != n_node_ints; ++i)
1377  newn->set_extra_integer(i, old_elem->node_ptr(n)->get_extra_integer(i));
1378 
1379 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1380  newn->set_unique_id(old_elem->node_ptr(n)->unique_id());
1381 #endif
1382  }
1383 
1384  // Define this element's connectivity on the new mesh
1385  new_elem->set_node(n) = new_mesh.node_ptr(this_node_id);
1386  }
1387 
1388  // Maybe add boundary conditions for this element
1389  for (auto s : old_elem->side_index_range())
1390  {
1391  this->get_boundary_info().boundary_ids(old_elem, s, bc_ids);
1392  new_mesh.get_boundary_info().add_side (new_elem, s, bc_ids);
1393  }
1394  } // end loop over elements
1395 
1396  // Prepare the new_mesh for use
1397  new_mesh.prepare_for_use();
1398 }
unique_id_type & set_unique_id()
Definition: dof_object.h:852
virtual Node *& set_node(const unsigned int i)
Definition: elem.h:2381
A Node is like a Point, but with more information.
Definition: node.h:52
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
void prepare_for_use(const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
Prepare a newly ecreated (or read) mesh for use.
Definition: mesh_base.C:710
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
void boundary_ids(const Node *node, std::vector< boundary_id_type > &vec_to_fill) const
Fills a user-provided std::vector with the boundary ids associated with Node node.
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
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
Add a new Node at Point p to the end of the vertex array, with processor_id procid.
virtual bool is_serial() const
Definition: mesh_base.h:205
virtual Elem * add_elem(Elem *e)=0
Add elem e to the end of the element array.
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Helper function that allows us to treat a homogenous pair as a range.
Definition: simple_range.h:57
virtual const Node * query_node_ptr(const dof_id_type i) const =0
libmesh_assert(ctx)
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > merge_extra_integer_names(const MeshBase &other)
Merge extra-integer arrays from an other mesh.
Definition: mesh_base.C:1861
virtual void clear()
Deletes all the element and node data that is currently stored.
Definition: mesh_base.C:862
void add_side(const dof_id_type elem, const unsigned short int side, const boundary_id_type id)
Add side side of element number elem with boundary id id to the boundary information data structure...
void add_extra_integers(const unsigned int n_integers)
Assigns a set of extra integers to this DofObject.
Definition: dof_object.C:490
virtual void delete_remote_elements()
When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local ele...
Definition: mesh_base.h:247
virtual dof_id_type n_elem() const =0
virtual const Node * node_ptr(const dof_id_type i) const =0
void set_extra_integer(const unsigned int index, const dof_id_type value)
Sets the value on this object of the extra integer associated with index, which should have been obta...
Definition: dof_object.h:1079
virtual dof_id_type n_nodes() const =0
uint8_t dof_id_type
Definition: id_types.h:67

◆ DECLARE_ELEM_ITERATORS() [1/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( )
inherited

Elem and Node iterator accessor functions.

See MeshBase for documentation.

◆ DECLARE_ELEM_ITERATORS() [2/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [3/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( ancestor_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [4/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( local_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [5/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( facelocal_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [6/20]

unsigned int level libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( pid_  ,
processor_id_type  pid,
pid   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [7/20]

unsigned int level ElemType type libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_subdomain_  ,
subdomain_id_type  sid,
sid   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [8/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( not_active_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [9/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( not_ancestor_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [10/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( not_subactive_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [11/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( not_local_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [12/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( not_level_  ,
unsigned int  level,
level   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [13/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_not_local_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [14/20]

libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_type_  ,
ElemType  type,
type   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [15/20]

processor_id_type pid libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( local_level_  ,
unsigned int  level,
level   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [16/20]

processor_id_type pid unsigned int level libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_local_subdomain_  ,
subdomain_id_type  sid,
sid   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [17/20]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( semilocal_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [18/20]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( active_semilocal_  )
inherited

◆ DECLARE_ELEM_ITERATORS() [19/20]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( multi_evaluable_  ,
std::vector< const DofMap *>  dof_maps,
dof_maps   
)
inherited

◆ DECLARE_ELEM_ITERATORS() [20/20]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::DistributedMesh::DECLARE_ELEM_ITERATORS ( flagged_pid_  ,
unsigned char rflag LIBMESH_COMMA processor_id_type  pid,
rflag LIBMESH_COMMA  pid 
)
inherited

◆ DECLARE_NODE_ITERATORS() [1/3]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::DistributedMesh::DECLARE_NODE_ITERATORS ( active_  )
inherited

◆ DECLARE_NODE_ITERATORS() [2/3]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::DistributedMesh::DECLARE_NODE_ITERATORS ( bnd_  )
inherited

◆ DECLARE_NODE_ITERATORS() [3/3]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid libMesh::DistributedMesh::DECLARE_NODE_ITERATORS ( bid_  ,
boundary_id_type  bid,
bid   
)
inherited

◆ default_ghosting()

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

Default ghosting functor.

Definition at line 1280 of file mesh_base.h.

References libMesh::MeshBase::_default_ghosting.

1280 { return *_default_ghosting; }
std::unique_ptr< GhostingFunctor > _default_ghosting
The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior...
Definition: mesh_base.h:1982

◆ default_mapping_data()

unsigned char libMesh::MeshBase::default_mapping_data ( ) const
inlineinherited

Returns any default data value used by the master space to physical space mapping.

Definition at line 809 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_data.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), MeshInputTest::helperTestingDynaQuad(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::VTKIO::nodes_to_vtk(), and MeshInputTest::testDynaReadPatch().

810  {
811  return _default_mapping_data;
812  }
unsigned char _default_mapping_data
The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational base...
Definition: mesh_base.h:1815

◆ default_mapping_type()

ElemMappingType libMesh::MeshBase::default_mapping_type ( ) const
inlineinherited

Returns the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 791 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_type.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::VTKIO::cells_to_vtk(), MeshInputTest::helperTestingDynaQuad(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::VTKIO::nodes_to_vtk(), libMesh::VTKIO::read(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaReadPatch(), and MeshInputTest::testExodusFileMappings().

792  {
793  return _default_mapping_type;
794  }
ElemMappingType _default_mapping_type
The default mapping type (typically Lagrange) between master and physical space to assign to newly ad...
Definition: mesh_base.h:1808

◆ delete_elem()

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

Removes element e from the mesh.

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

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

Implements libMesh::MeshBase.

Definition at line 711 of file distributed_mesh.C.

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

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

712 {
713  libmesh_assert (e);
714 
715  // Try to make the cached elem data more accurate
716  _n_elem--;
717 
718  // Was this a coarse element, not just a coarsening where we still
719  // have some ancestor structure? Was it a *local* element, that we
720  // might have been depending on as an owner of local nodes? We'll
721  // have to be more careful with our nodes in contract() later; no
722  // telling if we just locally orphaned a node that should be
723  // globally retained.
724  if (e->processor_id() == this->processor_id() &&
725  !e->parent())
727 
728  // Delete the element from the BoundaryInfo object
729  this->get_boundary_info().remove(e);
730 
731  // But not yet from the container; we might invalidate
732  // an iterator that way!
733 
734  //_elements.erase(e->id());
735 
736  // Instead, we set it to nullptr for now
737 
738  _elements[e->id()] = nullptr;
739 
740  // delete the element
741  delete e;
742 }
void remove(const Node *node)
Removes the boundary conditions associated with node node, if any exist.
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.
processor_id_type processor_id() const
bool _deleted_coarse_elements
A boolean remembering whether we&#39;ve recently deleted top-level elements or not.

◆ delete_node()

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

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 928 of file distributed_mesh.C.

References libMesh::MeshBase::_constraint_rows, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and libMesh::BoundaryInfo::remove().

929 {
930  libmesh_assert(n);
931  libmesh_assert(_nodes[n->id()]);
932 
933  // Try to make the cached elem data more accurate
934  _n_nodes--;
935 
936  // Delete the node from the BoundaryInfo object
937  this->get_boundary_info().remove(n);
938  _constraint_rows.erase(n);
939 
940  // But not yet from the container; we might invalidate
941  // an iterator that way!
942 
943  //_nodes.erase(n->id());
944 
945  // Instead, we set it to nullptr for now
946 
947  _nodes[n->id()] = nullptr;
948 
949  // delete the node
950  delete n;
951 }
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
void remove(const Node *node)
Removes the boundary conditions associated with node node, if any exist.
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ delete_remote_elements()

void libMesh::DistributedMesh::delete_remote_elements ( )
overridevirtualinherited

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

Reimplemented from libMesh::MeshBase.

Definition at line 1717 of file distributed_mesh.C.

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

1718 {
1719 #ifdef DEBUG
1720  // Make sure our neighbor links are all fine
1722 
1723  // And our child/parent links, and our flags
1725 
1726  // Make sure our ids and flags are consistent
1729 
1730  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1731  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1732  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1733  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1734  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1735  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1736 #endif
1737 
1738  _is_serial = false;
1739  _is_serial_on_proc_0 = false;
1740 
1741  MeshCommunication().delete_remote_elements(*this, _extra_ghost_elems);
1742 
1743  libmesh_assert_equal_to (this->max_elem_id(), this->parallel_max_elem_id());
1744 
1745  // Now make sure the containers actually shrink - strip
1746  // any newly-created nullptr voids out of the element array
1747  dofobject_container<Elem>::veclike_iterator e_it = _elements.begin();
1748  const dofobject_container<Elem>::veclike_iterator e_end = _elements.end();
1749  while (e_it != e_end)
1750  if (!*e_it)
1751  e_it = _elements.erase(e_it);
1752  else
1753  ++e_it;
1754 
1755  dofobject_container<Node>::veclike_iterator n_it = _nodes.begin();
1756  const dofobject_container<Node>::veclike_iterator n_end = _nodes.end();
1757  while (n_it != n_end)
1758  if (!*n_it)
1759  n_it = _nodes.erase(n_it);
1760  else
1761  ++n_it;
1762 
1763  // We may have deleted no-longer-connected nodes or coarsened-away
1764  // elements; let's update our caches.
1765  this->update_parallel_id_counts();
1766 
1767 #ifdef DEBUG
1768  // We might not have well-packed objects if the user didn't allow us
1769  // to renumber
1770  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1771  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1772 
1773  // Make sure our neighbor links are all fine
1775 
1776  // And our child/parent links, and our flags
1778 
1779  // Make sure our ids and flags are consistent
1782 #endif
1783 }
virtual void update_parallel_id_counts() override
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors...
virtual dof_id_type parallel_n_nodes() const override
virtual void libmesh_assert_valid_parallel_ids() const override
Verify id and processor_id consistency of our elements and nodes containers.
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
void libmesh_assert_valid_refinement_tree(const MeshBase &mesh)
A function for verifying that elements on this processor have valid descendants and consistent active...
Definition: mesh_tools.C:1416
virtual dof_id_type n_nodes() const override final
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.
void libmesh_assert_valid_parallel_flags() const
Verify refinement_flag and p_refinement_flag consistency of our elements containers.
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
friend class MeshCommunication
Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.
Definition: mesh_base.h:2039
virtual dof_id_type parallel_n_elem() const override
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...
dof_id_type parallel_max_node_id() const
dofobject_container< Elem > _elements
The elements in the mesh.
virtual dof_id_type max_node_id() const override final
virtual dof_id_type n_elem() const override final
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
A function for verifying that neighbor connectivity is correct (each element is a neighbor of or desc...
Definition: mesh_tools.C:2031
virtual dof_id_type max_elem_id() const override final
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )
inherited

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

Definition at line 1729 of file mesh_base.C.

References dim, libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), libMesh::make_range(), and libMesh::MeshBase::max_elem_id().

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

1730 {
1731  // This requires an inspection on every processor
1732  parallel_object_only();
1733 
1734  // Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
1735  if (this->elem_dimensions().size() == 1)
1736  return;
1737 
1738  //This map will be used to set interior parents
1739  std::unordered_map<dof_id_type, std::vector<dof_id_type>> node_to_elem;
1740 
1741  for (const auto & elem : this->active_element_ptr_range())
1742  {
1743  // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
1744  for (auto n : make_range(elem->n_vertices()))
1745  {
1746  libmesh_assert_less (elem->id(), this->max_elem_id());
1747 
1748  node_to_elem[elem->node_id(n)].push_back(elem->id());
1749  }
1750  }
1751 
1752  // Automatically set interior parents
1753  for (const auto & element : this->element_ptr_range())
1754  {
1755  // Ignore an 3D element or an element that already has an interior parent
1756  if (element->dim()>=LIBMESH_DIM || element->interior_parent())
1757  continue;
1758 
1759  // Start by generating a SET of elements that are dim+1 to the current
1760  // element at each vertex of the current element, thus ignoring interior nodes.
1761  // If one of the SET of elements is empty, then we will not have an interior parent
1762  // since an interior parent must be connected to all vertices of the current element
1763  std::vector<std::set<dof_id_type>> neighbors( element->n_vertices() );
1764 
1765  bool found_interior_parents = false;
1766 
1767  for (auto n : make_range(element->n_vertices()))
1768  {
1769  std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
1770  for (const auto & eid : element_ids)
1771  if (this->elem_ref(eid).dim() == element->dim()+1)
1772  neighbors[n].insert(eid);
1773 
1774  if (neighbors[n].size()>0)
1775  {
1776  found_interior_parents = true;
1777  }
1778  else
1779  {
1780  // We have found an empty set, no reason to continue
1781  // Ensure we set this flag to false before the break since it could have
1782  // been set to true for previous vertex
1783  found_interior_parents = false;
1784  break;
1785  }
1786  }
1787 
1788  // If we have successfully generated a set of elements for each vertex, we will compare
1789  // the set for vertex 0 will the sets for the vertices until we find a id that exists in
1790  // all sets. If found, this is our an interior parent id. The interior parent id found
1791  // will be the lowest element id if there is potential for multiple interior parents.
1792  if (found_interior_parents)
1793  {
1794  std::set<dof_id_type> & neighbors_0 = neighbors[0];
1795  for (const auto & interior_parent_id : neighbors_0)
1796  {
1797  found_interior_parents = false;
1798  for (auto n : make_range(1u, element->n_vertices()))
1799  {
1800  if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
1801  {
1802  found_interior_parents=true;
1803  }
1804  else
1805  {
1806  found_interior_parents=false;
1807  break;
1808  }
1809  }
1810  if (found_interior_parents)
1811  {
1812  element->set_interior_parent(this->elem_ptr(interior_parent_id));
1813  break;
1814  }
1815  }
1816  }
1817  }
1818 }
unsigned int dim
virtual dof_id_type max_elem_id() const =0
const std::set< unsigned char > & elem_dimensions() const
Definition: mesh_base.h:276
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual const Elem & elem_ref(const dof_id_type i) const
Definition: mesh_base.h:618
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134

◆ elem_dimensions()

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

Definition at line 276 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

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

277  { return _elem_dims; }
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895

◆ elem_ptr() [1/2]

const Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i) const
finaloverridevirtualinherited
Returns
A pointer to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 478 of file distributed_mesh.C.

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

Referenced by libMesh::DistributedMesh::DistributedMesh(), and libMesh::DistributedMesh::fix_broken_node_and_element_numbering().

479 {
481  libmesh_assert_equal_to (_elements[i]->id(), i);
482 
483  return _elements[i];
484 }
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.

◆ elem_ptr() [2/2]

Elem * libMesh::DistributedMesh::elem_ptr ( const dof_id_type  i)
finaloverridevirtualinherited
Returns
A writable pointer to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 489 of file distributed_mesh.C.

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

490 {
492  libmesh_assert_equal_to (_elements[i]->id(), i);
493 
494  return _elements[i];
495 }
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.

◆ elem_ref() [1/2]

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

Definition at line 618 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::SyncRefinementFlags::act_on_data(), libMesh::SyncSubdomainIds::act_on_data(), libMesh::SyncElementIntegers::act_on_data(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::SyncRefinementFlags::gather_data(), libMesh::SyncSubdomainIds::gather_data(), libMesh::SyncElementIntegers::gather_data(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), ExodusTest< elem_type >::meshes_equal_enough(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh_sides(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_remote_elem(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::FroIO::write(), libMesh::Nemesis_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

619  {
620  return *this->elem_ptr(i);
621  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0

◆ elem_ref() [2/2]

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

Definition at line 628 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

629  {
630  return *this->elem_ptr(i);
631  }
virtual const Elem * elem_ptr(const dof_id_type i) const =0

◆ extra_ghost_elems()

const std::set<Elem *>& libMesh::DistributedMesh::extra_ghost_elems ( ) const
inlineinherited

Const accessor to the ghosted elements.

Definition at line 261 of file distributed_mesh.h.

References libMesh::DistributedMesh::_extra_ghost_elems.

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

261 { return _extra_ghost_elems; }
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...

◆ find_neighbors()

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

Other functions from MeshBase requiring re-definition.

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

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

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

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

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

Implements libMesh::MeshBase.

Definition at line 864 of file unstructured_mesh.C.

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

Referenced by libMesh::TriangleWrapper::copy_tri_to_mesh(), and libMesh::Poly2TriTriangulator::insert_refinement_points().

866 {
867  // We might actually want to run this on an empty mesh
868  // (e.g. the boundary mesh for a nonexistent bcid!)
869  // libmesh_assert_not_equal_to (this->n_nodes(), 0);
870  // libmesh_assert_not_equal_to (this->n_elem(), 0);
871 
872  // This function must be run on all processors at once
873  parallel_object_only();
874 
875  LOG_SCOPE("find_neighbors()", "Mesh");
876 
877  //TODO:[BSK] This should be removed later?!
878  if (reset_current_list)
879  for (const auto & e : this->element_ptr_range())
880  for (auto s : e->side_index_range())
881  if (e->neighbor_ptr(s) != remote_elem || reset_remote_elements)
882  e->set_neighbor(s, nullptr);
883 
884  // Find neighboring elements by first finding elements
885  // with identical side keys and then check to see if they
886  // are neighbors
887  {
888  // data structures -- Use the hash_multimap if available
889  typedef dof_id_type key_type;
890  typedef std::pair<Elem *, unsigned char> val_type;
891  typedef std::unordered_multimap<key_type, val_type> map_type;
892 
893  // A map from side keys to corresponding elements & side numbers
894  map_type side_to_elem_map;
895 
896  // Pull objects out of the loop to reduce heap operations
897  std::unique_ptr<Elem> my_side, their_side;
898 
899  for (const auto & element : this->element_ptr_range())
900  {
901  for (auto ms : element->side_index_range())
902  {
903  next_side:
904  // If we haven't yet found a neighbor on this side, try.
905  // Even if we think our neighbor is remote, that
906  // information may be out of date.
907  if (element->neighbor_ptr(ms) == nullptr ||
908  element->neighbor_ptr(ms) == remote_elem)
909  {
910  // Get the key for the side of this element. Use the
911  // low_order_key so we can find neighbors in
912  // mixed-order meshes if necessary.
913  const dof_id_type key = element->low_order_key(ms);
914 
915  // Look for elements that have an identical side key
916  auto bounds = side_to_elem_map.equal_range(key);
917 
918  // May be multiple keys, check all the possible
919  // elements which _might_ be neighbors.
920  if (bounds.first != bounds.second)
921  {
922  // Get the side for this element
923  element->side_ptr(my_side, ms);
924 
925  // Look at all the entries with an equivalent key
926  while (bounds.first != bounds.second)
927  {
928  // Get the potential element
929  Elem * neighbor = bounds.first->second.first;
930 
931  // Get the side for the neighboring element
932  const unsigned int ns = bounds.first->second.second;
933  neighbor->side_ptr(their_side, ns);
934  //libmesh_assert(my_side.get());
935  //libmesh_assert(their_side.get());
936 
937  // If found a match with my side
938  //
939  // In 1D, since parents and children have an
940  // equal side (i.e. a node) we need to check
941  // for matching level() to avoid setting our
942  // neighbor pointer to any of our neighbor's
943  // descendants.
944  if ((*my_side == *their_side) &&
945  (element->level() == neighbor->level()))
946  {
947  // So share a side. Is this a mixed pair
948  // of subactive and active/ancestor
949  // elements?
950  // If not, then we're neighbors.
951  // If so, then the subactive's neighbor is
952 
953  if (element->subactive() ==
954  neighbor->subactive())
955  {
956  // an element is only subactive if it has
957  // been coarsened but not deleted
958  element->set_neighbor (ms,neighbor);
959  neighbor->set_neighbor(ns,element);
960  }
961  else if (element->subactive())
962  {
963  element->set_neighbor(ms,neighbor);
964  }
965  else if (neighbor->subactive())
966  {
967  neighbor->set_neighbor(ns,element);
968  }
969  side_to_elem_map.erase (bounds.first);
970 
971  // get out of this nested crap
972  goto next_side;
973  }
974 
975  ++bounds.first;
976  }
977  }
978 
979  // didn't find a match...
980  // Build the map entry for this element
981  side_to_elem_map.emplace
982  (key, std::make_pair(element, cast_int<unsigned char>(ms)));
983  }
984  }
985  }
986  }
987 
988 #ifdef LIBMESH_ENABLE_AMR
989 
1017  const unsigned int n_levels = MeshTools::n_levels(*this);
1018  for (unsigned int level = 1; level < n_levels; ++level)
1019  {
1020  for (auto & current_elem : as_range(level_elements_begin(level),
1021  level_elements_end(level)))
1022  {
1023  libmesh_assert(current_elem);
1024  Elem * parent = current_elem->parent();
1025  libmesh_assert(parent);
1026  const unsigned int my_child_num = parent->which_child_am_i(current_elem);
1027 
1028  for (auto s : current_elem->side_index_range())
1029  {
1030  if (current_elem->neighbor_ptr(s) == nullptr ||
1031  (current_elem->neighbor_ptr(s) == remote_elem &&
1032  parent->is_child_on_side(my_child_num, s)))
1033  {
1034  Elem * neigh = parent->neighbor_ptr(s);
1035 
1036  // If neigh was refined and had non-subactive children
1037  // made remote earlier, then our current elem should
1038  // actually have one of those remote children as a
1039  // neighbor
1040  if (neigh &&
1041  (neigh->ancestor() ||
1042  // If neigh has subactive children which should have
1043  // matched as neighbors of the current element but
1044  // did not, then those likewise must be remote
1045  // children.
1046  (current_elem->subactive() && neigh->has_children() &&
1047  (neigh->level()+1) == current_elem->level())))
1048  {
1049 #ifdef DEBUG
1050  // Let's make sure that "had children made remote"
1051  // situation is actually the case
1052  libmesh_assert(neigh->has_children());
1053  bool neigh_has_remote_children = false;
1054  for (auto & child : neigh->child_ref_range())
1055  if (&child == remote_elem)
1056  neigh_has_remote_children = true;
1057  libmesh_assert(neigh_has_remote_children);
1058 
1059  // And let's double-check that we don't have
1060  // a remote_elem neighboring an active local element
1061  if (current_elem->active())
1062  libmesh_assert_not_equal_to (current_elem->processor_id(),
1063  this->processor_id());
1064 #endif // DEBUG
1065  neigh = const_cast<RemoteElem *>(remote_elem);
1066  }
1067  // If neigh and current_elem are more than one level
1068  // apart, figuring out whether we have a remote
1069  // neighbor here becomes much harder.
1070  else if (neigh && (current_elem->subactive() &&
1071  neigh->has_children()))
1072  {
1073  // Find the deepest descendant of neigh which
1074  // we could consider for a neighbor. If we run
1075  // out of neigh children, then that's our
1076  // neighbor. If we find a potential neighbor
1077  // with remote_children and we don't find any
1078  // potential neighbors among its non-remote
1079  // children, then our neighbor must be remote.
1080  while (neigh != remote_elem &&
1081  neigh->has_children())
1082  {
1083  bool found_neigh = false;
1084  for (unsigned int c = 0, nc = neigh->n_children();
1085  !found_neigh && c != nc; ++c)
1086  {
1087  Elem * child = neigh->child_ptr(c);
1088  if (child == remote_elem)
1089  continue;
1090  for (auto ncn : child->neighbor_ptr_range())
1091  {
1092  if (ncn != remote_elem &&
1093  ncn->is_ancestor_of(current_elem))
1094  {
1095  neigh = ncn;
1096  found_neigh = true;
1097  break;
1098  }
1099  }
1100  }
1101  if (!found_neigh)
1102  neigh = const_cast<RemoteElem *>(remote_elem);
1103  }
1104  }
1105  current_elem->set_neighbor(s, neigh);
1106 #ifdef DEBUG
1107  if (neigh != nullptr && neigh != remote_elem)
1108  // We ignore subactive elements here because
1109  // we don't care about neighbors of subactive element.
1110  if ((!neigh->active()) && (!current_elem->subactive()))
1111  {
1112  libMesh::err << "On processor " << this->processor_id()
1113  << std::endl;
1114  libMesh::err << "Bad element ID = " << current_elem->id()
1115  << ", Side " << s << ", Bad neighbor ID = " << neigh->id() << std::endl;
1116  libMesh::err << "Bad element proc_ID = " << current_elem->processor_id()
1117  << ", Bad neighbor proc_ID = " << neigh->processor_id() << std::endl;
1118  libMesh::err << "Bad element size = " << current_elem->hmin()
1119  << ", Bad neighbor size = " << neigh->hmin() << std::endl;
1120  libMesh::err << "Bad element center = " << current_elem->vertex_average()
1121  << ", Bad neighbor center = " << neigh->vertex_average() << std::endl;
1122  libMesh::err << "ERROR: "
1123  << (current_elem->active()?"Active":"Ancestor")
1124  << " Element at level "
1125  << current_elem->level() << std::endl;
1126  libMesh::err << "with "
1127  << (parent->active()?"active":
1128  (parent->subactive()?"subactive":"ancestor"))
1129  << " parent share "
1130  << (neigh->subactive()?"subactive":"ancestor")
1131  << " neighbor at level " << neigh->level()
1132  << std::endl;
1133  NameBasedIO(*this).write ("bad_mesh.gmv");
1134  libmesh_error_msg("Problematic mesh written to bad_mesh.gmv.");
1135  }
1136 #endif // DEBUG
1137  }
1138  }
1139 
1140  // We can skip to the next element if we're full-dimension
1141  // and therefore don't have any interior parents
1142  if (current_elem->dim() >= LIBMESH_DIM)
1143  continue;
1144 
1145  // We have no interior parents unless we can find one later
1146  current_elem->set_interior_parent(nullptr);
1147 
1148  Elem * pip = parent->interior_parent();
1149 
1150  if (!pip)
1151  continue;
1152 
1153  // If there's no interior_parent children, whether due to a
1154  // remote element or a non-conformity, then there's no
1155  // children to search.
1156  if (pip == remote_elem || pip->active())
1157  {
1158  current_elem->set_interior_parent(pip);
1159  continue;
1160  }
1161 
1162  // For node comparisons we'll need a sensible tolerance
1163  Real node_tolerance = current_elem->hmin() * TOLERANCE;
1164 
1165  // Otherwise our interior_parent should be a child of our
1166  // parent's interior_parent.
1167  for (auto & child : pip->child_ref_range())
1168  {
1169  // If we have a remote_elem, that might be our
1170  // interior_parent. We'll set it provisionally now and
1171  // keep trying to find something better.
1172  if (&child == remote_elem)
1173  {
1174  current_elem->set_interior_parent
1175  (const_cast<RemoteElem *>(remote_elem));
1176  continue;
1177  }
1178 
1179  bool child_contains_our_nodes = true;
1180  for (auto & n : current_elem->node_ref_range())
1181  {
1182  bool child_contains_this_node = false;
1183  for (auto & cn : child.node_ref_range())
1184  if (cn.absolute_fuzzy_equals
1185  (n, node_tolerance))
1186  {
1187  child_contains_this_node = true;
1188  break;
1189  }
1190  if (!child_contains_this_node)
1191  {
1192  child_contains_our_nodes = false;
1193  break;
1194  }
1195  }
1196  if (child_contains_our_nodes)
1197  {
1198  current_elem->set_interior_parent(&child);
1199  break;
1200  }
1201  }
1202 
1203  // We should have found *some* interior_parent at this
1204  // point, whether semilocal or remote.
1205  libmesh_assert(current_elem->interior_parent());
1206  }
1207  }
1208 
1209 #endif // AMR
1210 
1211 
1212 #ifdef DEBUG
1214  !reset_remote_elements);
1216 #endif
1217 }
OStreamProxy err
This class supports simple reads and writes in any libMesh-supported format, by dispatching to one of...
Definition: namebased_io.h:44
const Elem * parent() const
Definition: elem.h:2867
In parallel meshes where a ghost element has neighbors which do not exist on the local processor...
Definition: remote_elem.h:59
bool is_ancestor_of(const Elem *descendant) const
Definition: elem.h:2846
void libmesh_assert_valid_amr_interior_parents(const MeshBase &mesh)
A function for verifying that any interior_parent pointers on elements are consistent with AMR (paren...
Definition: mesh_tools.C:1213
const Elem * interior_parent() const
Definition: elem.C:994
static constexpr Real TOLERANCE
virtual bool is_child_on_side(const unsigned int c, const unsigned int s) const =0
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
virtual unsigned int n_children() const =0
void set_interior_parent(Elem *p)
Sets the pointer to the element&#39;s interior_parent.
Definition: elem.C:1056
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2188
bool ancestor() const
Definition: elem.C:1634
dof_id_type id() const
Definition: dof_object.h:823
virtual Real hmin() const
Definition: elem.C:512
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Helper function that allows us to treat a homogenous pair as a range.
Definition: simple_range.h:57
unsigned int n_levels(const MeshBase &mesh)
Definition: mesh_tools.C:801
virtual void write(const std::string &mesh_file) override
This method implements writing a mesh to a specified file.
Definition: namebased_io.C:310
libmesh_assert(ctx)
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition: elem.h:2427
unsigned int which_child_am_i(const Elem *e) const
Definition: elem.h:3029
SimpleRange< NodeRefIter > node_ref_range()
Returns a range with all nodes of an element, usable in range-based for loops.
Definition: elem.h:2474
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2407
unsigned int level() const
Definition: elem.h:2911
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::unique_ptr< Elem > side_ptr(unsigned int i)=0
bool subactive() const
Definition: elem.h:2796
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition: elem.h:3326
void libmesh_assert_valid_neighbors(const MeshBase &mesh, bool assert_valid_remote_elems=true)
A function for verifying that neighbor connectivity is correct (each element is a neighbor of or desc...
Definition: mesh_tools.C:2031
processor_id_type processor_id() const
bool active() const
Definition: elem.h:2778
processor_id_type processor_id() const
Definition: dof_object.h:898
bool has_children() const
Definition: elem.h:2816
Point vertex_average() const
Definition: elem.C:498
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3000
uint8_t dof_id_type
Definition: id_types.h:67
const RemoteElem * remote_elem
Definition: remote_elem.C:54

◆ fix_broken_node_and_element_numbering()

void libMesh::DistributedMesh::fix_broken_node_and_element_numbering ( )
overridevirtualinherited

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

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

Implements libMesh::MeshBase.

Definition at line 1662 of file distributed_mesh.C.

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

1663 {
1664  // We can't use range-for here because we need access to the special
1665  // iterators' methods, not just to their dereferenced values.
1666 
1667  // Nodes first
1668  for (auto pr = this->_nodes.begin(),
1669  end = this->_nodes.end(); pr != end; ++pr)
1670  {
1671  Node * n = *pr;
1672  if (n != nullptr)
1673  {
1674  const dof_id_type id = pr.index();
1675  n->set_id() = id;
1676  libmesh_assert_equal_to(this->node_ptr(id), n);
1677  }
1678  }
1679 
1680  // Elements next
1681  for (auto pr = this->_elements.begin(),
1682  end = this->_elements.end(); pr != end; ++pr)
1683  {
1684  Elem * e = *pr;
1685  if (e != nullptr)
1686  {
1687  const dof_id_type id = pr.index();
1688  e->set_id() = id;
1689  libmesh_assert_equal_to(this->elem_ptr(id), e);
1690  }
1691  }
1692 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
virtual const Elem * elem_ptr(const dof_id_type i) const override final
dofobject_container< Elem > _elements
The elements in the mesh.
uint8_t dof_id_type
Definition: id_types.h:67
virtual const Node * node_ptr(const dof_id_type i) const override final

◆ gather_to_zero()

void libMesh::DistributedMesh::gather_to_zero ( )
overridevirtualinherited

Gathers all elements and nodes of the mesh onto processor zero.

Reimplemented from libMesh::MeshBase.

Definition at line 1837 of file distributed_mesh.C.

References libMesh::DistributedMesh::_is_serial_on_proc_0, and libMesh::MeshBase::MeshCommunication.

1838 {
1840  return;
1841 
1842  _is_serial_on_proc_0 = true;
1843  MeshCommunication().gather(0, *this);
1844 }
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
friend class MeshCommunication
Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.
Definition: mesh_base.h:2039

◆ get_boundary_info() [1/2]

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

The information about boundary ids on the mesh.

Definition at line 159 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), LinearElasticity::assemble(), HDGProblem::assemble(), assemble_elasticity(), assemble_poisson(), assemble_shell(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), AssemblyA0::boundary_assembly(), AssemblyA1::boundary_assembly(), AssemblyF0::boundary_assembly(), AssemblyF1::boundary_assembly(), AssemblyA2::boundary_assembly(), AssemblyF2::boundary_assembly(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshBase::get_info(), libMesh::UNVIO::groups_in(), HDGProblem::init(), libMesh::ExodusII_IO_Helper::initialize(), LinearElasticityWithContact::initialize_contact_load_paths(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshTools::Modification::orient_elements(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::CheckpointIO::read_header(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_nodesets(), MeshStitchTest::renameAndShift(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::ReplicatedMesh::ReplicatedMesh(), SolidSystem::side_time_derivative(), libMesh::PetscDiffSolver::solve(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), AllTriTest::test_helper_2D(), AllTriTest::test_helper_3D(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), SystemsTest::testBoundaryProjectCube(), BoundaryInfoTest::testEdgeBoundaryConditions(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryInfoTest::testMesh(), BoundaryInfoTest::testNameCopying(), PeriodicBCTest::testPeriodicBC(), MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testShellFaceConstraints(), WriteNodesetData::testWriteImpl(), WriteEdgesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::ExodusII_IO::write(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

159 { return *boundary_info; }
std::unique_ptr< BoundaryInfo > boundary_info
This class holds the boundary information.
Definition: mesh_base.h:1760

◆ get_boundary_info() [2/2]

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

Writable information about boundary ids on the mesh.

Definition at line 164 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

164 { return *boundary_info; }
std::unique_ptr< BoundaryInfo > boundary_info
This class holds the boundary information.
Definition: mesh_base.h:1760

◆ get_constraint_rows() [1/2]

constraint_rows_type& libMesh::MeshBase::get_constraint_rows ( )
inlineinherited

◆ get_constraint_rows() [2/2]

const constraint_rows_type& libMesh::MeshBase::get_constraint_rows ( ) const
inlineinherited

Definition at line 1686 of file mesh_base.h.

References libMesh::MeshBase::_constraint_rows.

1687  { return _constraint_rows; }
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009

◆ get_count_lower_dim_elems_in_point_locator()

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

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 1612 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

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

1613 {
1615 }
bool _count_lower_dim_elems_in_point_locator
Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based po...
Definition: mesh_base.h:1835

◆ get_elem_integer_index()

unsigned int libMesh::MeshBase::get_elem_integer_index ( std::string_view  name) const
inherited

Definition at line 578 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_names, libMesh::index_range(), libMesh::invalid_uint, and libMesh::Quality::name().

Referenced by libMesh::MeshBase::change_elemset_code(), WriteElemsetData::checkElemsetCodes(), ExtraIntegersTest::testExtraIntegersExodusReading(), and libMesh::ExodusII_IO_Helper::write_elemsets().

579 {
580  for (auto i : index_range(_elem_integer_names))
581  if (_elem_integer_names[i] == name)
582  return i;
583 
584  libmesh_error_msg("Unknown elem integer " << name);
585  return libMesh::invalid_uint;
586 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:286
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ get_elem_integer_name()

const std::string& libMesh::MeshBase::get_elem_integer_name ( unsigned int  i) const
inlineinherited

Definition at line 923 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names.

Referenced by libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

924  { return _elem_integer_names[i]; }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938

◆ get_elemset_code()

dof_id_type libMesh::MeshBase::get_elemset_code ( const MeshBase::elemset_type id_set) const
inherited

Definition at line 391 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes_inverse_map, and libMesh::DofObject::invalid_id.

Referenced by WriteElemsetData::checkElemsetCodes(), and libMesh::ExodusII_IO::read().

392 {
393  auto it = _elemset_codes_inverse_map.find(id_set);
394  return (it == _elemset_codes_inverse_map.end()) ? DofObject::invalid_id : it->second;
395 }
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477

◆ get_elemset_codes()

std::vector< dof_id_type > libMesh::MeshBase::get_elemset_codes ( ) const
inherited

Return a vector of all elemset codes defined on the mesh.

We get this by looping over the _elemset_codes map.

Definition at line 397 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), and libMesh::XdrIO::write().

398 {
399  std::vector<dof_id_type> ret;
400  ret.reserve(_elemset_codes.size());
401  for (const auto & pr : _elemset_codes)
402  ret.push_back(pr.first);
403  return ret;
404 }
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924

◆ get_elemsets()

void libMesh::MeshBase::get_elemsets ( dof_id_type  elemset_code,
MeshBase::elemset_type id_set_to_fill 
) const
inherited

Look up the element sets for a given elemset code and vice-versa.

The elemset must have been previously stored by calling add_elemset_code(). If no such code/set is found, returns the empty set or DofObject::invalid_id, respectively.

Definition at line 381 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), WriteElemsetData::testWriteImpl(), libMesh::XdrIO::write(), and libMesh::ExodusII_IO_Helper::write_elemsets().

382 {
383  // If we don't recognize this elemset_code, hand back an empty set
384  id_set_to_fill.clear();
385 
386  auto it = _elemset_codes.find(elemset_code);
387  if (it != _elemset_codes.end())
388  id_set_to_fill.insert(it->second->begin(), it->second->end());
389 }
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924

◆ get_id_by_name()

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

Definition at line 1639 of file mesh_base.C.

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

1640 {
1641  // Linear search over the map values.
1642  std::map<subdomain_id_type, std::string>::const_iterator
1643  iter = _block_id_to_name.begin(),
1644  end_iter = _block_id_to_name.end();
1645 
1646  for ( ; iter != end_iter; ++iter)
1647  if (iter->second == name)
1648  return iter->first;
1649 
1650  // If we made it here without returning, we don't have a subdomain
1651  // with the requested name, so return Elem::invalid_subdomain_id.
1653 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static const subdomain_id_type invalid_subdomain_id
A static integral constant representing an invalid subdomain id.
Definition: elem.h:238
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888

◆ get_info()

std::string libMesh::MeshBase::get_info ( const unsigned int  verbosity = 0,
const bool  global = true 
) const
inherited
Returns
A string containing relevant information about the mesh.

verbosity sets the verbosity, with 0 being the least and 2 being the greatest. 0 - Dimensions, number of nodes, number of elems, number of subdomains, number of partitions, prepared status. 1 - Adds the mesh bounding box, mesh element types, specific nodesets/edgesets/sidesets with element types, number of nodes/edges/sides. 2 - Adds volume information and bounding boxes to boundary information.

The global parameter pertains primarily to verbosity levels 1 and above. When global == true, information is only output on rank 0 and the information is reduced. When global == false, information is output on all ranks that pertains only to that local partition.

Definition at line 1022 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_elemset_codes, libMesh::Elem::build_edge_ptr(), libMesh::ParallelObject::comm(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_local_bounding_box(), libMesh::MeshTools::elem_types(), libMesh::Utility::enum_to_string(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_edge_boundary_ids(), libMesh::BoundaryInfo::get_edgeset_name_map(), libMesh::BoundaryInfo::get_node_boundary_ids(), libMesh::BoundaryInfo::get_nodeset_name_map(), libMesh::BoundaryInfo::get_side_boundary_ids(), libMesh::BoundaryInfo::get_sideset_name_map(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_replicated(), libMesh::libmesh_assert(), libMesh::Elem::loose_bounding_box(), TIMPI::Communicator::max(), TIMPI::Communicator::min(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_elemsets(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::MeshBase::n_local_subdomains(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::n_subdomains(), libMesh::n_threads(), libMesh::Quality::name(), libMesh::Elem::node_ref_range(), libMesh::ParallelObject::processor_id(), libMesh::Real, TIMPI::Communicator::set_union(), libMesh::MeshBase::spatial_dimension(), TIMPI::Communicator::sum(), libMesh::Elem::type(), libMesh::BoundingBox::union_with(), and libMesh::Elem::volume().

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

1023 {
1024  std::ostringstream oss;
1025 
1026  oss << " Mesh Information:" << '\n';
1027 
1028  if (!_elem_dims.empty())
1029  {
1030  oss << " elem_dimensions()={";
1031  std::copy(_elem_dims.begin(),
1032  --_elem_dims.end(), // --end() is valid if the set is non-empty
1033  std::ostream_iterator<unsigned int>(oss, ", "));
1034  oss << cast_int<unsigned int>(*_elem_dims.rbegin());
1035  oss << "}\n";
1036  }
1037 
1038  oss << " spatial_dimension()=" << this->spatial_dimension() << '\n'
1039  << " n_nodes()=" << this->n_nodes() << '\n'
1040  << " n_local_nodes()=" << this->n_local_nodes() << '\n'
1041  << " n_elem()=" << this->n_elem() << '\n'
1042  << " n_local_elem()=" << this->n_local_elem() << '\n';
1043 #ifdef LIBMESH_ENABLE_AMR
1044  oss << " n_active_elem()=" << this->n_active_elem() << '\n';
1045 #endif
1046  if (global)
1047  oss << " n_subdomains()=" << static_cast<std::size_t>(this->n_subdomains()) << '\n';
1048  else
1049  oss << " n_local_subdomains()= " << static_cast<std::size_t>(this->n_local_subdomains()) << '\n';
1050  oss << " n_elemsets()=" << static_cast<std::size_t>(this->n_elemsets()) << '\n';
1051  if (!_elemset_codes.empty())
1052  oss << " n_elemset_codes=" << _elemset_codes.size() << '\n';
1053  oss << " n_partitions()=" << static_cast<std::size_t>(this->n_partitions()) << '\n'
1054  << " n_processors()=" << static_cast<std::size_t>(this->n_processors()) << '\n'
1055  << " n_threads()=" << static_cast<std::size_t>(libMesh::n_threads()) << '\n'
1056  << " processor_id()=" << static_cast<std::size_t>(this->processor_id()) << '\n'
1057  << " is_prepared()=" << (this->is_prepared() ? "true" : "false") << '\n'
1058  << " is_replicated()=" << (this->is_replicated() ? "true" : "false") << '\n';
1059 
1060  if (verbosity > 0)
1061  {
1062  if (global)
1063  {
1064  libmesh_parallel_only(this->comm());
1065  if (this->processor_id() != 0)
1066  oss << "\n Detailed global get_info() (verbosity > 0) is reduced and output to only rank 0.";
1067  }
1068 
1069  // Helper for printing element types
1070  const auto elem_type_helper = [](const std::set<int> & elem_types) {
1071  std::stringstream ss;
1072  for (auto it = elem_types.begin(); it != elem_types.end();)
1073  {
1074  ss << Utility::enum_to_string((ElemType)*it);
1075  if (++it != elem_types.end())
1076  ss << ", ";
1077  }
1078  return ss.str();
1079  };
1080 
1081  // Helper for whether or not the given DofObject is to be included. If we're doing
1082  // a global reduction, we also count unpartitioned objects on rank 0.
1083  const auto include_object = [this, &global](const DofObject & dof_object) {
1084  return this->processor_id() == dof_object.processor_id() ||
1085  (global &&
1086  this->processor_id() == 0 &&
1087  dof_object.processor_id() == DofObject::invalid_processor_id);
1088  };
1089 
1090  Real volume = 0;
1091 
1092  // Add bounding box information
1093  const auto bbox = global ? MeshTools::create_bounding_box(*this) : MeshTools::create_local_bounding_box(*this);
1094  if (!global || this->processor_id() == 0)
1095  oss << "\n " << (global ? "" : "Local ") << "Mesh Bounding Box:\n"
1096  << " Minimum: " << bbox.min() << "\n"
1097  << " Maximum: " << bbox.max() << "\n"
1098  << " Delta: " << (bbox.max() - bbox.min()) << "\n";
1099 
1100  // Obtain the global or local element types
1101  std::set<int> elem_types;
1102  for (const Elem * elem : this->active_local_element_ptr_range())
1103  elem_types.insert(elem->type());
1104  if (global)
1105  {
1106  // Pick up unpartitioned elems on rank 0
1107  if (this->processor_id() == 0)
1108  for (const Elem * elem : this->active_unpartitioned_element_ptr_range())
1109  elem_types.insert(elem->type());
1110 
1111  this->comm().set_union(elem_types);
1112  }
1113 
1114  // Add element types
1115  if (!global || this->processor_id() == 0)
1116  oss << "\n " << (global ? "" : "Local ") << "Mesh Element Type(s):\n "
1117  << elem_type_helper(elem_types) << "\n";
1118 
1119  // Reduce the nodeset ids
1120  auto nodeset_ids = this->get_boundary_info().get_node_boundary_ids();
1121  if (global)
1122  this->comm().set_union(nodeset_ids);
1123 
1124  // Accumulate local information for each nodeset
1125  struct NodesetInfo
1126  {
1127  std::size_t num_nodes = 0;
1128  BoundingBox bbox;
1129  };
1130  std::map<boundary_id_type, NodesetInfo> nodeset_info_map;
1131  for (const auto & [node, id] : this->get_boundary_info().get_nodeset_map())
1132  {
1133  if (!include_object(*node))
1134  continue;
1135 
1136  NodesetInfo & info = nodeset_info_map[id];
1137 
1138  ++info.num_nodes;
1139 
1140  if (verbosity > 1)
1141  info.bbox.union_with(*node);
1142  }
1143 
1144  // Add nodeset info
1145  if (!global || this->processor_id() == 0)
1146  {
1147  oss << "\n " << (global ? "" : "Local ") << "Mesh Nodesets:\n";
1148  if (nodeset_ids.empty())
1149  oss << " None\n";
1150  }
1151 
1152  const auto & nodeset_name_map = this->get_boundary_info().get_nodeset_name_map();
1153  for (const auto id : nodeset_ids)
1154  {
1155  NodesetInfo & info = nodeset_info_map[id];
1156 
1157  // Reduce the local information for this nodeset if required
1158  if (global)
1159  {
1160  this->comm().sum(info.num_nodes);
1161  if (verbosity > 1)
1162  {
1163  this->comm().min(info.bbox.min());
1164  this->comm().max(info.bbox.max());
1165  }
1166  }
1167 
1168  const bool has_name = nodeset_name_map.count(id) && nodeset_name_map.at(id).size();
1169  const std::string name = has_name ? nodeset_name_map.at(id) : "";
1170  if (global)
1171  libmesh_assert(this->comm().verify(name));
1172 
1173  if (global ? this->processor_id() == 0 : info.num_nodes > 0)
1174  {
1175  oss << " Nodeset " << id;
1176  if (has_name)
1177  oss << " (" << name << ")";
1178  oss << ", " << info.num_nodes << " " << (global ? "" : "local ") << "nodes\n";
1179 
1180  if (verbosity > 1)
1181  {
1182  oss << " " << (global ? "Bounding" : "Local bounding") << " box minimum: "
1183  << info.bbox.min() << "\n"
1184  << " " << (global ? "Bounding" : "Local bounding") << " box maximum: "
1185  << info.bbox.max() << "\n"
1186  << " " << (global ? "Bounding" : "Local bounding") << " box delta: "
1187  << (info.bbox.max() - info.bbox.min()) << "\n";
1188  }
1189  }
1190  }
1191 
1192  // Reduce the sideset ids
1193  auto sideset_ids = this->get_boundary_info().get_side_boundary_ids();
1194  if (global)
1195  this->comm().set_union(sideset_ids);
1196 
1197  // Accumulate local information for each sideset
1198  struct SidesetInfo
1199  {
1200  std::size_t num_sides = 0;
1201  Real volume = 0;
1202  std::set<int> side_elem_types;
1203  std::set<int> elem_types;
1204  std::set<dof_id_type> elem_ids;
1205  std::set<dof_id_type> node_ids;
1206  BoundingBox bbox;
1207  };
1208  ElemSideBuilder side_builder;
1209  std::map<boundary_id_type, SidesetInfo> sideset_info_map;
1210  for (const auto & pair : this->get_boundary_info().get_sideset_map())
1211  {
1212  const Elem * elem = pair.first;
1213  if (!include_object(*elem))
1214  continue;
1215 
1216  const auto id = pair.second.second;
1217  SidesetInfo & info = sideset_info_map[id];
1218 
1219  const auto s = pair.second.first;
1220  const Elem & side = side_builder(*elem, s);
1221 
1222  ++info.num_sides;
1223  info.side_elem_types.insert(side.type());
1224  info.elem_types.insert(elem->type());
1225  info.elem_ids.insert(elem->id());
1226 
1227  for (const Node & node : side.node_ref_range())
1228  if (include_object(node))
1229  info.node_ids.insert(node.id());
1230 
1231  if (verbosity > 1)
1232  {
1233  info.volume += side.volume();
1234  info.bbox.union_with(side.loose_bounding_box());
1235  }
1236  }
1237 
1238  // Add sideset info
1239  if (!global || this->processor_id() == 0)
1240  {
1241  oss << "\n " << (global ? "" : "Local ") << "Mesh Sidesets:\n";
1242  if (sideset_ids.empty())
1243  oss << " None\n";
1244  }
1245  const auto & sideset_name_map = this->get_boundary_info().get_sideset_name_map();
1246  for (const auto id : sideset_ids)
1247  {
1248  SidesetInfo & info = sideset_info_map[id];
1249 
1250  auto num_elems = info.elem_ids.size();
1251  auto num_nodes = info.node_ids.size();
1252 
1253  // Reduce the local information for this sideset if required
1254  if (global)
1255  {
1256  this->comm().sum(info.num_sides);
1257  this->comm().set_union(info.side_elem_types, 0);
1258  this->comm().sum(num_elems);
1259  this->comm().set_union(info.elem_types, 0);
1260  this->comm().sum(num_nodes);
1261  if (verbosity > 1)
1262  {
1263  this->comm().sum(info.volume);
1264  this->comm().min(info.bbox.min());
1265  this->comm().max(info.bbox.max());
1266  }
1267  }
1268 
1269  const bool has_name = sideset_name_map.count(id) && sideset_name_map.at(id).size();
1270  const std::string name = has_name ? sideset_name_map.at(id) : "";
1271  if (global)
1272  libmesh_assert(this->comm().verify(name));
1273 
1274  if (global ? this->processor_id() == 0 : info.num_sides > 0)
1275  {
1276  oss << " Sideset " << id;
1277  if (has_name)
1278  oss << " (" << name << ")";
1279  oss << ", " << info.num_sides << " sides (" << elem_type_helper(info.side_elem_types) << ")"
1280  << ", " << num_elems << " " << (global ? "" : "local ") << "elems (" << elem_type_helper(info.elem_types) << ")"
1281  << ", " << num_nodes << " " << (global ? "" : "local ") << "nodes\n";
1282 
1283  if (verbosity > 1)
1284  {
1285  oss << " " << (global ? "Side" : "Local side") << " volume: " << info.volume << "\n"
1286  << " " << (global ? "Bounding" : "Local bounding") << " box minimum: "
1287  << info.bbox.min() << "\n"
1288  << " " << (global ? "Bounding" : "Local bounding") << " box maximum: "
1289  << info.bbox.max() << "\n"
1290  << " " << (global ? "Bounding" : "Local bounding") << " box delta: "
1291  << (info.bbox.max() - info.bbox.min()) << "\n";
1292  }
1293  }
1294  }
1295 
1296  // Reduce the edgeset ids
1297  auto edgeset_ids = this->get_boundary_info().get_edge_boundary_ids();
1298  if (global)
1299  this->comm().set_union(edgeset_ids);
1300 
1301  // Accumulate local information for each edgeset
1302  struct EdgesetInfo
1303  {
1304  std::size_t num_edges = 0;
1305  std::set<int> edge_elem_types;
1306  BoundingBox bbox;
1307  };
1308  std::map<boundary_id_type, EdgesetInfo> edgeset_info_map;
1309  std::unique_ptr<const Elem> edge;
1310 
1311  for (const auto & pair : this->get_boundary_info().get_edgeset_map())
1312  {
1313  const Elem * elem = pair.first;
1314  if (!include_object(*elem))
1315  continue;
1316 
1317  const auto id = pair.second.second;
1318  EdgesetInfo & info = edgeset_info_map[id];
1319 
1320  elem->build_edge_ptr(edge, pair.second.first);
1321 
1322  ++info.num_edges;
1323  info.edge_elem_types.insert(edge->type());
1324 
1325  if (verbosity > 1)
1326  info.bbox.union_with(edge->loose_bounding_box());
1327  }
1328 
1329  // Add edgeset info
1330  if (!global || this->processor_id() == 0)
1331  {
1332  oss << "\n " << (global ? "" : "Local ") << "Mesh Edgesets:\n";
1333  if (edgeset_ids.empty())
1334  oss << " None\n";
1335  }
1336 
1337  const auto & edgeset_name_map = this->get_boundary_info().get_edgeset_name_map();
1338  for (const auto id : edgeset_ids)
1339  {
1340  EdgesetInfo & info = edgeset_info_map[id];
1341 
1342  // Reduce the local information for this edgeset if required
1343  if (global)
1344  {
1345  this->comm().sum(info.num_edges);
1346  this->comm().set_union(info.edge_elem_types, 0);
1347  if (verbosity > 1)
1348  {
1349  this->comm().min(info.bbox.min());
1350  this->comm().min(info.bbox.max());
1351  }
1352  }
1353 
1354  const bool has_name = edgeset_name_map.count(id) && edgeset_name_map.at(id).size();
1355  const std::string name = has_name ? edgeset_name_map.at(id) : "";
1356  if (global)
1357  libmesh_assert(this->comm().verify(name));
1358 
1359  if (global ? this->processor_id() == 0 : info.num_edges > 0)
1360  {
1361  oss << " Edgeset " << id;
1362  if (has_name)
1363  oss << " (" << name << ")";
1364  oss << ", " << info.num_edges << " " << (global ? "" : "local ") << "edges ("
1365  << elem_type_helper(info.edge_elem_types) << ")\n";
1366 
1367  if (verbosity > 1)
1368  {
1369  oss << " " << (global ? "Bounding" : "Local bounding") << " box minimum: "
1370  << info.bbox.min() << "\n"
1371  << " " << (global ? "Bounding" : "Local bounding") << " box maximum: "
1372  << info.bbox.max() << "\n"
1373  << " " << (global ? "Bounding" : "Local bounding") << " box delta: "
1374  << (info.bbox.max() - info.bbox.min()) << "\n";
1375  }
1376  }
1377  }
1378 
1379  // Reduce the block IDs and block names
1380  std::set<subdomain_id_type> subdomains;
1381  for (const Elem * elem : this->active_element_ptr_range())
1382  if (include_object(*elem))
1383  subdomains.insert(elem->subdomain_id());
1384  if (global)
1385  this->comm().set_union(subdomains);
1386 
1387  // Accumulate local information for each subdomain
1388  struct SubdomainInfo
1389  {
1390  std::size_t num_elems = 0;
1391  Real volume = 0;
1392  std::set<int> elem_types;
1393  std::set<dof_id_type> active_node_ids;
1394 #ifdef LIBMESH_ENABLE_AMR
1395  std::size_t num_active_elems = 0;
1396 #endif
1397  BoundingBox bbox;
1398  };
1399  std::map<subdomain_id_type, SubdomainInfo> subdomain_info_map;
1400  for (const Elem * elem : this->element_ptr_range())
1401  if (include_object(*elem))
1402  {
1403  SubdomainInfo & info = subdomain_info_map[elem->subdomain_id()];
1404 
1405  ++info.num_elems;
1406  info.elem_types.insert(elem->type());
1407 
1408 #ifdef LIBMESH_ENABLE_AMR
1409  if (elem->active())
1410  ++info.num_active_elems;
1411 #endif
1412 
1413  for (const Node & node : elem->node_ref_range())
1414  if (include_object(node) && node.active())
1415  info.active_node_ids.insert(node.id());
1416 
1417  if (verbosity > 1 && elem->active())
1418  {
1419  info.volume += elem->volume();
1420  info.bbox.union_with(elem->loose_bounding_box());
1421  }
1422  }
1423 
1424  // Add subdomain info
1425  oss << "\n " << (global ? "" : "Local ") << "Mesh Subdomains:\n";
1426  const auto & subdomain_name_map = this->get_subdomain_name_map();
1427  for (const auto id : subdomains)
1428  {
1429  SubdomainInfo & info = subdomain_info_map[id];
1430 
1431  auto num_active_nodes = info.active_node_ids.size();
1432 
1433  // Reduce the information for this subdomain if needed
1434  if (global)
1435  {
1436  this->comm().sum(info.num_elems);
1437 #ifdef LIBMESH_ENABLE_AMR
1438  this->comm().sum(info.num_active_elems);
1439 #endif
1440  this->comm().sum(num_active_nodes);
1441  this->comm().set_union(info.elem_types, 0);
1442  if (verbosity > 1)
1443  {
1444  this->comm().min(info.bbox.min());
1445  this->comm().max(info.bbox.max());
1446  this->comm().sum(info.volume);
1447  }
1448  }
1449  if (verbosity > 1)
1450  volume += info.volume;
1451 
1452  const bool has_name = subdomain_name_map.count(id);
1453  const std::string name = has_name ? subdomain_name_map.at(id) : "";
1454  if (global)
1455  libmesh_assert(this->comm().verify(name));
1456 
1457  if (!global || this->processor_id() == 0)
1458  {
1459  oss << " Subdomain " << id;
1460  if (has_name)
1461  oss << " (" << name << ")";
1462  oss << ": " << info.num_elems << " " << (global ? "" : "local ") << "elems "
1463  << "(" << elem_type_helper(info.elem_types);
1464 #ifdef LIBMESH_ENABLE_AMR
1465  oss << ", " << info.num_active_elems << " active";
1466 #endif
1467  oss << "), " << num_active_nodes << " " << (global ? "" : "local ") << "active nodes\n";
1468  if (verbosity > 1)
1469  {
1470  oss << " " << (global ? "Volume" : "Local volume") << ": " << info.volume << "\n";
1471  oss << " " << (global ? "Bounding" : "Local bounding") << " box minimum: "
1472  << info.bbox.min() << "\n"
1473  << " " << (global ? "Bounding" : "Local bounding") << " box maximum: "
1474  << info.bbox.max() << "\n"
1475  << " " << (global ? "Bounding" : "Local bounding") << " box delta: "
1476  << (info.bbox.max() - info.bbox.min()) << "\n";
1477  }
1478  }
1479  }
1480 
1481  oss << " " << (global ? "Global" : "Local") << " mesh volume = " << volume << "\n";
1482 
1483  }
1484 
1485  return oss.str();
1486 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
ElemType
Defines an enum for geometric element types.
void elem_types(const MeshBase &mesh, std::vector< ElemType > &et)
Fills in a vector of all element types in the mesh.
Definition: mesh_tools.C:715
const std::set< boundary_id_type > & get_side_boundary_ids() const
bool is_prepared() const
Definition: mesh_base.h:192
virtual dof_id_type n_active_elem() const =0
unsigned int n_threads()
Definition: libmesh_base.h:96
MPI_Info info
libMesh::BoundingBox create_bounding_box(const MeshBase &mesh)
Definition: mesh_tools.C:558
subdomain_id_type n_local_subdomains() const
Definition: mesh_base.C:951
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924
void sum(T &r) const
const std::map< boundary_id_type, std::string > & get_sideset_name_map() const
dof_id_type n_local_nodes() const
Definition: mesh_base.h:421
const Parallel::Communicator & comm() const
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
dof_id_type n_local_elem() const
Definition: mesh_base.h:527
libMesh::BoundingBox create_local_bounding_box(const MeshBase &mesh)
Definition: mesh_tools.C:623
const std::set< boundary_id_type > & get_node_boundary_ids() const
processor_id_type n_processors() const
const std::map< boundary_id_type, std::string > & get_nodeset_name_map() const
void min(const T &r, T &o, Request &req) const
const std::map< subdomain_id_type, std::string > & get_subdomain_name_map() const
Definition: mesh_base.h:1671
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
const Point & min() const
Definition: bounding_box.h:76
const std::map< boundary_id_type, std::string > & get_edgeset_name_map() const
libmesh_assert(ctx)
unsigned int n_elemsets() const
Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set.
Definition: mesh_base.C:376
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895
std::string enum_to_string(const T e)
unsigned int n_partitions() const
Definition: mesh_base.h:1322
subdomain_id_type n_subdomains() const
Definition: mesh_base.C:937
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void max(const T &r, T &o, Request &req) const
unsigned int spatial_dimension() const
Definition: mesh_base.C:495
const std::set< boundary_id_type > & get_edge_boundary_ids() const
virtual bool is_replicated() const
Definition: mesh_base.h:227
virtual dof_id_type n_elem() const =0
processor_id_type processor_id() const
virtual dof_id_type n_nodes() const =0
void set_union(T &data, const unsigned int root_id) const

◆ get_mesh_subdomains()

const std::set<subdomain_id_type>& libMesh::MeshBase::get_mesh_subdomains ( ) const
inlineinherited
Returns
The cached mesh subdomains. As long as the mesh is prepared, this should contain all the subdomain ids across processors. Relies on the mesh being prepared

Definition at line 1744 of file mesh_base.h.

References libMesh::MeshBase::_mesh_subdomains, libMesh::MeshBase::is_prepared(), and libMesh::libmesh_assert().

1745  { libmesh_assert(this->is_prepared()); return _mesh_subdomains; }
std::set< subdomain_id_type > _mesh_subdomains
We cache the subdomain ids of the elements present in the mesh.
Definition: mesh_base.h:1900
bool is_prepared() const
Definition: mesh_base.h:192
libmesh_assert(ctx)

◆ get_node_integer_index()

unsigned int libMesh::MeshBase::get_node_integer_index ( std::string_view  name) const
inherited

Definition at line 667 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_names, libMesh::index_range(), libMesh::invalid_uint, and libMesh::Quality::name().

668 {
669  for (auto i : index_range(_node_integer_names))
670  if (_node_integer_names[i] == name)
671  return i;
672 
673  libmesh_error_msg("Unknown node integer " << name);
674  return libMesh::invalid_uint;
675 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:286
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ get_node_integer_name()

const std::string& libMesh::MeshBase::get_node_integer_name ( unsigned int  i) const
inlineinherited

Definition at line 1045 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names.

Referenced by libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

1046  { return _node_integer_names[i]; }
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950

◆ get_point_locator_close_to_point_tol()

Real libMesh::MeshBase::get_point_locator_close_to_point_tol ( ) const
inherited

Definition at line 1836 of file mesh_base.C.

References libMesh::MeshBase::_point_locator_close_to_point_tol.

1837 {
1839 }
Real _point_locator_close_to_point_tol
If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we crea...
Definition: mesh_base.h:2015

◆ get_subdomain_name_map()

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

Definition at line 1671 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshBase::get_info(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

1672  { return _block_id_to_name; }
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888

◆ ghosting_functors_begin()

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

Beginning of range of ghosting functors.

Definition at line 1268 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), libMesh::MeshBase::redistribute(), and EquationSystemsTest::testDisableDefaultGhosting().

1269  { return _ghosting_functors.begin(); }
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991

◆ ghosting_functors_end()

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

End of range of ghosting functors.

Definition at line 1274 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), libMesh::MeshBase::redistribute(), and EquationSystemsTest::testDisableDefaultGhosting().

1275  { return _ghosting_functors.end(); }
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991

◆ has_elem_integer()

bool libMesh::MeshBase::has_elem_integer ( std::string_view  name) const
inherited

Definition at line 590 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_names, and libMesh::Quality::name().

Referenced by libMesh::MeshBase::change_elemset_code(), WriteElemsetData::checkElemsetCodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::ExodusII_IO_Helper::initialize(), ExtraIntegersTest::testExtraIntegersExodusReading(), and libMesh::ExodusII_IO_Helper::write_elemsets().

591 {
592  for (auto & entry : _elem_integer_names)
593  if (entry == name)
594  return true;
595 
596  return false;
597 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938

◆ has_node_integer()

bool libMesh::MeshBase::has_node_integer ( std::string_view  name) const
inherited

Definition at line 679 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_names, and libMesh::Quality::name().

Referenced by ExtraIntegersTest::checkpoint_helper().

680 {
681  for (auto & entry : _node_integer_names)
682  if (entry == name)
683  return true;
684 
685  return false;
686 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950

◆ insert_elem() [1/2]

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

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

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

Implements libMesh::MeshBase.

Definition at line 654 of file distributed_mesh.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_n_elem, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::DistributedMesh::delete_elem(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

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

655 {
656  if (_elements[e->id()])
657  this->delete_elem(_elements[e->id()]);
658 
659 #ifdef LIBMESH_ENABLE_UNIQUE_ID
660  if (!e->valid_unique_id())
661  {
662  if (processor_id() == e->processor_id())
663  {
664  e->set_unique_id(_next_unique_id);
665  _next_unique_id += this->n_processors() + 1;
666  }
667  else
668  {
669  e->set_unique_id(_next_unpartitioned_unique_id);
671  }
672  }
673  else
674  {
675  _next_unique_id = std::max(_next_unique_id, e->unique_id()+1);
677  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
678  (this->n_processors() + 1) + this->processor_id();
679  }
680 #endif
681 
682  // Try to make the cached elem data more accurate
683  processor_id_type elem_procid = e->processor_id();
684  if (elem_procid == this->processor_id() ||
685  elem_procid == DofObject::invalid_processor_id)
686  _n_elem++;
687 
688  _elements[e->id()] = e;
689 
690  // Make sure any new element is given space for any extra integers
691  // we've requested
692  e->add_extra_integers(_elem_integer_names.size(),
694 
695  // And set mapping type and data on any new element
696  e->set_mapping_type(this->default_mapping_type());
697  e->set_mapping_data(this->default_mapping_data());
698 
699  return e;
700 }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
virtual void delete_elem(Elem *e) override final
Removes element e from the mesh.
ElemMappingType default_mapping_type() const
Returns the default master space to physical space mapping basis functions to be used on newly added ...
Definition: mesh_base.h:791
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
uint8_t processor_id_type
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
unsigned char default_mapping_data() const
Returns any default data value used by the master space to physical space mapping.
Definition: mesh_base.h:809
dofobject_container< Elem > _elements
The elements in the mesh.
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
processor_id_type processor_id() const

◆ insert_elem() [2/2]

Elem * libMesh::DistributedMesh::insert_elem ( std::unique_ptr< Elem e)
finaloverridevirtualinherited

Version of insert_elem() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Elem is transferred to the Mesh when this function is called, and it should play more nicely with the Elem::build() API which has always returned a std::unique_ptr.

Implements libMesh::MeshBase.

Definition at line 702 of file distributed_mesh.C.

References libMesh::DistributedMesh::insert_elem().

703 {
704  // The mesh now takes ownership of the Elem. Eventually the guts of
705  // insert_elem(Elem*) will get moved to a private helper function, and
706  // calling insert_elem(Elem*) directly will be deprecated.
707  return insert_elem(e.release());
708 }
virtual Elem * insert_elem(Elem *e) override final
Insert elem e to the element array, preserving its id and replacing/deleting any existing element wit...

◆ insert_node() [1/2]

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

These methods are deprecated.

Please use add_node instead Calls add_node().

Implements libMesh::MeshBase.

Definition at line 914 of file distributed_mesh.C.

References libMesh::DistributedMesh::add_node().

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

915 {
916  libmesh_deprecated();
917  return DistributedMesh::add_node(n);
918 }
virtual Node * add_node(Node *n) override final
Add Node n to the end of the vertex array.

◆ insert_node() [2/2]

Node * libMesh::DistributedMesh::insert_node ( std::unique_ptr< Node n)
finaloverridevirtualinherited

This method is deprecated.

Please use add_node instead Version of insert_node() taking a std::unique_ptr by value. This API is intended to indicate that ownership of the Node is transferred to the Mesh when this function is called, and it should play more nicely with the Node::build() API which has always returned a std::unique_ptr.

Implements libMesh::MeshBase.

Definition at line 920 of file distributed_mesh.C.

References libMesh::DistributedMesh::insert_node().

921 {
922  libmesh_deprecated();
923  return insert_node(n.release());
924 }
virtual Node * insert_node(Node *n) override final
These methods are deprecated.

◆ is_prepared()

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

◆ is_replicated()

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

Reimplemented from libMesh::MeshBase.

Definition at line 176 of file distributed_mesh.h.

177  { return false; }

◆ is_serial()

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

Reimplemented from libMesh::MeshBase.

Definition at line 154 of file distributed_mesh.h.

References libMesh::DistributedMesh::_is_serial.

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

155  { return _is_serial; }
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.

◆ is_serial_on_zero()

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

Reimplemented from libMesh::MeshBase.

Definition at line 161 of file distributed_mesh.h.

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

162  { return _is_serial || _is_serial_on_proc_0; }
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.

◆ libmesh_assert_valid_parallel_flags()

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

Verify refinement_flag and p_refinement_flag consistency of our elements containers.

Calls libmesh_assert() on each possible failure.

Definition at line 1170 of file distributed_mesh.C.

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

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

1171 {
1172 #if defined(LIBMESH_ENABLE_AMR) && !defined(NDEBUG)
1173  // This function must be run on all processors at once
1174  parallel_object_only();
1175 
1176  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1177 
1178  for (dof_id_type i=0; i != pmax_elem_id; ++i)
1179  {
1180  Elem * el = _elements[i]; // Returns nullptr if there's no map entry
1181 
1182  unsigned int refinement_flag = el ?
1183  static_cast<unsigned int> (el->refinement_flag()) : libMesh::invalid_uint;
1184  unsigned int p_refinement_flag = el ?
1185  static_cast<unsigned int> (el->p_refinement_flag()) : libMesh::invalid_uint;
1186 
1187  libmesh_assert(this->comm().semiverify(el ? &refinement_flag : nullptr));
1188 
1189  // p refinement flags aren't always kept correct on inactive
1190  // ghost elements
1191  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_refinement_flag : nullptr));
1192  }
1193 #endif // LIBMESH_ENABLE_AMR
1194 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:286
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ libmesh_assert_valid_parallel_ids()

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

Verify id and processor_id consistency of our elements and nodes containers.

Calls libmesh_assert() on each possible failure.

Reimplemented from libMesh::MeshBase.

Definition at line 1139 of file distributed_mesh.C.

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

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

1140 {
1143 }
void libmesh_assert_valid_parallel_object_ids(const dofobject_container< T > &) const
Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container...
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
dofobject_container< Elem > _elements
The elements in the mesh.

◆ libmesh_assert_valid_parallel_object_ids()

template<typename T >
void libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids ( const dofobject_container< T > &  objects) const
inherited

Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container.

Calls libmesh_assert() on each possible failure in that container.

Definition at line 1083 of file distributed_mesh.C.

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

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

1084 {
1085  // This function must be run on all processors at once
1086  parallel_object_only();
1087 
1088  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1089  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1090  const dof_id_type pmax_id = std::max(pmax_node_id, pmax_elem_id);
1091 
1092  for (dof_id_type i=0; i != pmax_id; ++i)
1093  {
1094  T * obj = objects[i]; // Returns nullptr if there's no map entry
1095 
1096  // Local lookups by id should return the requested object
1097  libmesh_assert(!obj || obj->id() == i);
1098 
1099  // All processors with an object should agree on id
1100 #ifndef NDEBUG
1101  const dof_id_type dofid = obj && obj->valid_id() ?
1102  obj->id() : DofObject::invalid_id;
1103  libmesh_assert(this->comm().semiverify(obj ? &dofid : nullptr));
1104 #endif
1105 
1106  // All processors with an object should agree on processor id
1107  const dof_id_type procid = obj && obj->valid_processor_id() ?
1108  obj->processor_id() : DofObject::invalid_processor_id;
1109  libmesh_assert(this->comm().semiverify(obj ? &procid : nullptr));
1110 
1111  dof_id_type min_procid = procid;
1112  this->comm().min(min_procid);
1113 
1114  // Either:
1115  // 1.) I own this elem (min_procid == this->processor_id()) *and* I have a valid pointer to it (obj != nullptr)
1116  // or
1117  // 2.) I don't own this elem (min_procid != this->processor_id()). (In this case I may or may not have a valid pointer to it.)
1118 
1119  // Original assert logic
1120  // libmesh_assert (min_procid != this->processor_id() || obj);
1121 
1122  // More human-understandable logic...
1123  libmesh_assert (
1124  ((min_procid == this->processor_id()) && obj)
1125  ||
1126  (min_procid != this->processor_id())
1127  );
1128 
1129 #if defined(LIBMESH_ENABLE_UNIQUE_ID) && !defined(NDEBUG)
1130  // All processors with an object should agree on unique id
1131  const unique_id_type uniqueid = obj ? obj->unique_id() : 0;
1132  libmesh_assert(this->comm().semiverify(obj ? &uniqueid : nullptr));
1133 #endif
1134  }
1135 }
const Parallel::Communicator & comm() const
void min(const T &r, T &o, Request &req) const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
dof_id_type parallel_max_node_id() const
processor_id_type processor_id() const
uint8_t unique_id_type
Definition: id_types.h:86
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ libmesh_assert_valid_parallel_p_levels()

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

Verify p_level consistency of our elements containers.

Calls libmesh_assert() on each possible failure.

Definition at line 1147 of file distributed_mesh.C.

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

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

1148 {
1149 #ifndef NDEBUG
1150  // This function must be run on all processors at once
1151  parallel_object_only();
1152 
1153  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1154 
1155  for (dof_id_type i=0; i != pmax_elem_id; ++i)
1156  {
1157  Elem * el = _elements[i]; // Returns nullptr if there's no map entry
1158 
1159  unsigned int p_level = el ? (el->p_level()) : libMesh::invalid_uint;
1160 
1161  // All processors with an active element should agree on p level
1162  libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_level : nullptr));
1163  }
1164 #endif
1165 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:286
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ locally_equals()

bool libMesh::MeshBase::locally_equals ( const MeshBase other_mesh) const
inherited

This behaves the same as operator==, but only for the local and ghosted aspects of the mesh; i.e.

operator== is true iff local equality is true on every rank.

Definition at line 222 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids, libMesh::MeshBase::_allow_remote_element_removal, libMesh::MeshBase::_block_id_to_name, libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::_count_lower_dim_elems_in_point_locator, libMesh::MeshBase::_default_ghosting, libMesh::MeshBase::_default_mapping_data, libMesh::MeshBase::_default_mapping_type, libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_elemset_codes, libMesh::MeshBase::_ghosting_functors, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_mesh_subdomains, libMesh::MeshBase::_n_parts, libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::_partitioner, libMesh::MeshBase::_point_locator_close_to_point_tol, libMesh::MeshBase::_skip_all_partitioning, libMesh::MeshBase::_skip_find_neighbors, libMesh::MeshBase::_skip_noncritical_partitioning, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::_spatial_dimension, libMesh::MeshBase::boundary_info, libMesh::MeshBase::get_constraint_rows(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::MeshBase::query_node_ptr(), and libMesh::MeshBase::subclass_locally_equals().

Referenced by libMesh::MeshBase::operator==().

223 {
224  // Check whether everything in the base is equal
225  if (_n_parts != other_mesh._n_parts ||
226  _default_mapping_type != other_mesh._default_mapping_type ||
227  _default_mapping_data != other_mesh._default_mapping_data ||
228  _is_prepared != other_mesh._is_prepared ||
230  other_mesh._count_lower_dim_elems_in_point_locator ||
231  // We expect this to change in a DistributeMesh prepare_for_use();
232  // it's conceptually "mutable"...
233 /*
234 #ifdef LIBMESH_ENABLE_UNIQUE_ID
235  _next_unique_id != other_mesh._next_unique_id ||
236 #endif
237 */
238  _skip_noncritical_partitioning != other_mesh._skip_noncritical_partitioning ||
239  _skip_all_partitioning != other_mesh._skip_all_partitioning ||
240  _skip_renumber_nodes_and_elements != other_mesh._skip_renumber_nodes_and_elements ||
241  _skip_find_neighbors != other_mesh._skip_find_neighbors ||
242  _allow_remote_element_removal != other_mesh._allow_remote_element_removal ||
243  _spatial_dimension != other_mesh._spatial_dimension ||
244  _point_locator_close_to_point_tol != other_mesh._point_locator_close_to_point_tol ||
245  _block_id_to_name != other_mesh._block_id_to_name ||
246  _elem_dims != other_mesh._elem_dims ||
247  _mesh_subdomains != other_mesh._mesh_subdomains ||
248  _all_elemset_ids != other_mesh._all_elemset_ids ||
249  _elem_integer_names != other_mesh._elem_integer_names ||
250  _elem_integer_default_values != other_mesh._elem_integer_default_values ||
251  _node_integer_names != other_mesh._node_integer_names ||
252  _node_integer_default_values != other_mesh._node_integer_default_values ||
253  bool(_default_ghosting) != bool(other_mesh._default_ghosting) ||
254  bool(_partitioner) != bool(other_mesh._partitioner) ||
255  *boundary_info != *other_mesh.boundary_info)
256  return false;
257 
258  const constraint_rows_type & other_rows =
259  other_mesh.get_constraint_rows();
260  for (const auto & [node, row] : this->_constraint_rows)
261  {
262  const dof_id_type node_id = node->id();
263  const Node * other_node = other_mesh.query_node_ptr(node_id);
264  if (!other_node)
265  return false;
266 
267  auto it = other_rows.find(other_node);
268  if (it == other_rows.end())
269  return false;
270 
271  const auto & other_row = it->second;
272  if (row.size() != other_row.size())
273  return false;
274 
275  for (auto i : index_range(row))
276  {
277  const auto & [elem_pair, coef] = row[i];
278  const auto & [other_elem_pair, other_coef] = other_row[i];
279  libmesh_assert(elem_pair.first);
280  libmesh_assert(other_elem_pair.first);
281  if (elem_pair.first->id() !=
282  other_elem_pair.first->id() ||
283  elem_pair.second !=
284  other_elem_pair.second ||
285  coef != other_coef)
286  return false;
287  }
288  }
289 
290  for (const auto & [elemset_code, elemset_ptr] : this->_elemset_codes)
291  {
292  auto it = other_mesh._elemset_codes.find(elemset_code);
293  if (it == other_mesh._elemset_codes.end() ||
294  *elemset_ptr != *it->second)
295  return false;
296  }
297 
298  // FIXME: we have no good way to compare ghosting functors, since
299  // they're in a set sorted by pointer, and we have no way *at all*
300  // to compare ghosting functors, since they don't have operator==
301  // defined and we encourage users to subclass them. We can check if
302  // we have the same number, is all.
303  if (_ghosting_functors.size() !=
304  other_mesh._ghosting_functors.size())
305  return false;
306 
307  // Same deal for partitioners. We tested that we both have one or
308  // both don't, but are they equivalent? Let's guess "yes".
309 
310  // Now let the subclasses decide whether everything else is equal
311  return this->subclass_locally_equals(other_mesh);
312 }
std::set< subdomain_id_type > _mesh_subdomains
We cache the subdomain ids of the elements present in the mesh.
Definition: mesh_base.h:1900
virtual bool subclass_locally_equals(const MeshBase &other_mesh) const =0
Shim to allow operator == (&) to behave like a virtual function without having to be one...
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
std::map< dof_id_type, const MeshBase::elemset_type * > _elemset_codes
Map from "element set code" to list of set ids to which that element belongs (and vice-versa)...
Definition: mesh_base.h:1924
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
bool _skip_noncritical_partitioning
If this is true then no partitioning should be done with the possible exception of orphaned nodes...
Definition: mesh_base.h:1856
unsigned char _spatial_dimension
The "spatial dimension" of the Mesh.
Definition: mesh_base.h:1932
std::unique_ptr< BoundaryInfo > boundary_info
This class holds the boundary information.
Definition: mesh_base.h:1760
bool _allow_remote_element_removal
If this is false then even on DistributedMesh remote elements will not be deleted during mesh prepara...
Definition: mesh_base.h:1881
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
MeshBase::elemset_type _all_elemset_ids
Definition: mesh_base.h:1926
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802
unsigned char _default_mapping_data
The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational base...
Definition: mesh_base.h:1815
ElemMappingType _default_mapping_type
The default mapping type (typically Lagrange) between master and physical space to assign to newly ad...
Definition: mesh_base.h:1808
std::unique_ptr< Partitioner > _partitioner
A partitioner to use at each prepare_for_use().
Definition: mesh_base.h:1843
libmesh_assert(ctx)
bool _skip_find_neighbors
If this is true then we will skip find_neighbors in prepare_for_use.
Definition: mesh_base.h:1873
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895
std::vector< dof_id_type > _node_integer_default_values
The array of default initialization values for integer data associated with each node in the mesh...
Definition: mesh_base.h:1956
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944
std::map< const Node *, constraint_rows_mapped_type > constraint_rows_type
Definition: mesh_base.h:1675
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820
std::unique_ptr< GhostingFunctor > _default_ghosting
The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior...
Definition: mesh_base.h:1982
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861
Real _point_locator_close_to_point_tol
If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we crea...
Definition: mesh_base.h:2015
bool _count_lower_dim_elems_in_point_locator
Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based po...
Definition: mesh_base.h:1835
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
uint8_t dof_id_type
Definition: id_types.h:67

◆ max_elem_id()

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

◆ max_node_id()

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

◆ merge_extra_integer_names()

std::pair< std::vector< unsigned int >, std::vector< unsigned int > > libMesh::MeshBase::merge_extra_integer_names ( const MeshBase other)
protectedinherited

Merge extra-integer arrays from an other mesh.

Returns two mappings from index values in other to (possibly newly created) index values with the same string name in this mesh, the first for element integers and the second for node integers.

Definition at line 1861 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::add_elem_integers(), and libMesh::MeshBase::add_node_integers().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::UnstructuredMesh::create_submesh().

1862 {
1863  std::pair<std::vector<unsigned int>, std::vector<unsigned int>> returnval;
1864  returnval.first = this->add_elem_integers(other._elem_integer_names, true, &other._elem_integer_default_values);
1865  returnval.second = this->add_node_integers(other._node_integer_names, true, &other._node_integer_default_values);
1866  return returnval;
1867 }
std::vector< unsigned int > add_elem_integers(const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
Register integer data (of type dof_id_type) to be added to each element in the mesh, one string name for each new integer.
Definition: mesh_base.C:535
std::vector< unsigned int > add_node_integers(const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
Register integer data (of type dof_id_type) to be added to each node in the mesh. ...
Definition: mesh_base.C:624

◆ mesh_dimension()

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

Definition at line 324 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), libMesh::MeshTools::Modification::all_tri(), alternative_fe_assembly(), assemble(), LinearElasticity::assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::MeshBase::cache_elem_data(), compute_enriched_soln(), compute_jacobian(), compute_residual(), compute_stresses(), LinearElasticityWithContact::compute_stresses(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::distort(), SolidSystem::element_time_derivative(), HeatSystem::element_time_derivative(), fe_assembly(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::LaplaceMeshSmoother::init(), SolidSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), integrate_function(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), main(), libMesh::GMVIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::System::read_header(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_connectivity(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), LinearElasticityWithContact::residual_and_jacobian(), SolidSystem::save_initial_mesh(), setup(), libMesh::MeshTools::Modification::smooth(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), libMesh::BoundaryVolumeSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_nodal_data(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), and libMesh::EnsightIO::write_vector_ascii().

325 {
326  if (!_elem_dims.empty())
327  return cast_int<unsigned int>(*_elem_dims.rbegin());
328  return 0;
329 }
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895

◆ move_nodes_and_elements()

virtual void libMesh::UnstructuredMesh::move_nodes_and_elements ( MeshBase &&  other_mesh)
pure virtualinherited

Move node and elements from other_mesh to this mesh.

Implemented in libMesh::ReplicatedMesh.

◆ n_active_elem()

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

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

Definition at line 1696 of file distributed_mesh.C.

References libMesh::ParallelObject::comm(), distance(), libMesh::DofObject::invalid_processor_id, and TIMPI::Communicator::sum().

1697 {
1698  parallel_object_only();
1699 
1700  // Get local active elements first
1701  dof_id_type active_elements =
1702  static_cast<dof_id_type>(std::distance (this->active_local_elements_begin(),
1703  this->active_local_elements_end()));
1704  this->comm().sum(active_elements);
1705 
1706  // Then add unpartitioned active elements, which should exist on
1707  // every processor
1708  active_elements +=
1709  static_cast<dof_id_type>(std::distance
1710  (this->active_pid_elements_begin(DofObject::invalid_processor_id),
1711  this->active_pid_elements_end(DofObject::invalid_processor_id)));
1712  return active_elements;
1713 }
void sum(T &r) const
const Parallel::Communicator & comm() const
Real distance(const Point &p)
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_active_elem_on_proc()

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

Definition at line 989 of file mesh_base.C.

References distance(), and libMesh::ParallelObject::n_processors().

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

990 {
991  libmesh_assert_less (proc_id, this->n_processors());
992  return static_cast<dof_id_type>(std::distance (this->active_pid_elements_begin(proc_id),
993  this->active_pid_elements_end (proc_id)));
994 }
Real distance(const Point &p)
processor_id_type n_processors() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_active_local_elem()

dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const
inlineinherited

◆ n_active_sub_elem()

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

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

Definition at line 1010 of file mesh_base.C.

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

1011 {
1012  dof_id_type ne=0;
1013 
1014  for (const auto & elem : this->active_element_ptr_range())
1015  ne += elem->n_sub_elem();
1016 
1017  return ne;
1018 }
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_elem()

virtual dof_id_type libMesh::DistributedMesh::n_elem ( ) const
inlinefinaloverridevirtualinherited
Returns
The number of elements in the mesh.

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

Implements libMesh::MeshBase.

Definition at line 267 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_elem.

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

267 { return _n_elem; }

◆ n_elem_integers()

unsigned int libMesh::MeshBase::n_elem_integers ( ) const
inlineinherited

Definition at line 934 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names.

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

934 { return _elem_integer_names.size(); }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938

◆ n_elem_on_proc()

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

Definition at line 976 of file mesh_base.C.

References distance(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), and libMesh::ParallelObject::n_processors().

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

977 {
978  // We're either counting a processor's elements or unpartitioned
979  // elements
980  libmesh_assert (proc_id < this->n_processors() ||
982 
983  return static_cast<dof_id_type>(std::distance (this->pid_elements_begin(proc_id),
984  this->pid_elements_end (proc_id)));
985 }
Real distance(const Point &p)
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_elemsets()

unsigned int libMesh::MeshBase::n_elemsets ( ) const
inherited

Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set.

Definition at line 376 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids.

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

377 {
378  return _all_elemset_ids.size();
379 }
MeshBase::elemset_type _all_elemset_ids
Definition: mesh_base.h:1926

◆ n_local_elem()

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

Definition at line 527 of file mesh_base.h.

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

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

528  { 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:976
processor_id_type processor_id() const

◆ n_local_nodes()

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

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

422  { 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:963
processor_id_type processor_id() const

◆ n_local_subdomains()

subdomain_id_type libMesh::MeshBase::n_local_subdomains ( ) const
inherited
Returns
The number of subdomains in the local 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 951 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

952 {
953  std::set<subdomain_id_type> ids;
954 
955  this->subdomain_ids (ids, /* global = */ false);
956 
957  return cast_int<subdomain_id_type>(ids.size());
958 }
void subdomain_ids(std::set< subdomain_id_type > &ids, const bool global=true) const
Constructs a list of all subdomain identifiers in the local mesh if global == false, and in the global mesh if global == true (default).
Definition: mesh_base.C:899

◆ n_node_integers()

unsigned int libMesh::MeshBase::n_node_integers ( ) const
inlineinherited

Definition at line 1056 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names.

Referenced by libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

1056 { return _node_integer_names.size(); }
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950

◆ n_nodes()

virtual dof_id_type libMesh::DistributedMesh::n_nodes ( ) const
inlinefinaloverridevirtualinherited
Returns
The number of nodes in the mesh.

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

Implements libMesh::MeshBase.

Definition at line 264 of file distributed_mesh.h.

References libMesh::DistributedMesh::_n_nodes.

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

264 { return _n_nodes; }
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.

◆ n_nodes_on_proc()

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

Definition at line 963 of file mesh_base.C.

References distance(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), and libMesh::ParallelObject::n_processors().

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

964 {
965  // We're either counting a processor's nodes or unpartitioned
966  // nodes
967  libmesh_assert (proc_id < this->n_processors() ||
969 
970  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
971  this->pid_nodes_end (proc_id)));
972 }
Real distance(const Point &p)
processor_id_type n_processors() const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_partitions()

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

Definition at line 1322 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

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

1323  { return _n_parts; }
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802

◆ n_processors()

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

Definition at line 103 of file parallel_object.h.

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

◆ n_sub_elem()

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

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

Definition at line 998 of file mesh_base.C.

999 {
1000  dof_id_type ne=0;
1001 
1002  for (const auto & elem : this->element_ptr_range())
1003  ne += elem->n_sub_elem();
1004 
1005  return ne;
1006 }
uint8_t dof_id_type
Definition: id_types.h:67

◆ n_subdomains()

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

Definition at line 937 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

938 {
939  // This requires an inspection on every processor
940  parallel_object_only();
941 
942  std::set<subdomain_id_type> ids;
943 
944  this->subdomain_ids (ids);
945 
946  return cast_int<subdomain_id_type>(ids.size());
947 }
void subdomain_ids(std::set< subdomain_id_type > &ids, const bool global=true) const
Constructs a list of all subdomain identifiers in the local mesh if global == false, and in the global mesh if global == true (default).
Definition: mesh_base.C:899

◆ n_unpartitioned_elem()

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

Definition at line 533 of file mesh_base.h.

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

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

dof_id_type n_elem_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:976
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488

◆ n_unpartitioned_nodes()

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

Definition at line 427 of file mesh_base.h.

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

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

static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
dof_id_type n_nodes_on_proc(const processor_id_type proc) const
Definition: mesh_base.C:963

◆ next_unique_id()

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

Definition at line 440 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

440 { return _next_unique_id; }
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849

◆ node_ptr() [1/2]

const Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i) const
finaloverridevirtualinherited
Returns
A pointer to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 424 of file distributed_mesh.C.

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

Referenced by libMesh::DistributedMesh::fix_broken_node_and_element_numbering(), and ExodusTest< elem_type >::meshes_equal_enough().

425 {
427  libmesh_assert_equal_to (_nodes[i]->id(), i);
428 
429  return _nodes[i];
430 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ node_ptr() [2/2]

Node * libMesh::DistributedMesh::node_ptr ( const dof_id_type  i)
finaloverridevirtualinherited
Returns
A writable pointer to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Implements libMesh::MeshBase.

Definition at line 435 of file distributed_mesh.C.

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

436 {
438  libmesh_assert_equal_to (_nodes[i]->id(), i);
439 
440  return _nodes[i];
441 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ node_ref() [1/2]

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

◆ node_ref() [2/2]

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

Definition at line 584 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

585  {
586  return *this->node_ptr(i);
587  }
virtual const Node * node_ptr(const dof_id_type i) const =0

◆ nodes_and_elements_equal()

bool libMesh::MeshBase::nodes_and_elements_equal ( const MeshBase other_mesh) const
protectedinherited

Tests for equality of all elements and nodes in the mesh.

Helper function for subclass_equals() in unstructured mesh subclasses.

Definition at line 1906 of file mesh_base.C.

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

1907 {
1908  for (const auto & other_node : other_mesh.node_ptr_range())
1909  {
1910  const Node * node = this->query_node_ptr(other_node->id());
1911  if (!node)
1912  return false;
1913  if (*other_node != *node)
1914  return false;
1915  }
1916  for (const auto & node : this->node_ptr_range())
1917  if (!other_mesh.query_node_ptr(node->id()))
1918  return false;
1919 
1920  for (const auto & other_elem : other_mesh.element_ptr_range())
1921  {
1922  const Elem * elem = this->query_elem_ptr(other_elem->id());
1923  if (!elem)
1924  return false;
1925  if (!other_elem->topologically_equal(*elem))
1926  return false;
1927  }
1928  for (const auto & elem : this->element_ptr_range())
1929  if (!other_mesh.query_elem_ptr(elem->id()))
1930  return false;
1931 
1932  return true;
1933 }
virtual const Node * query_node_ptr(const dof_id_type i) const =0
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0

◆ operator!=()

bool libMesh::MeshBase::operator!= ( const MeshBase other_mesh) const
inlineinherited

Definition at line 128 of file mesh_base.h.

129  {
130  return !(*this == other_mesh);
131  }

◆ operator==()

bool libMesh::MeshBase::operator== ( const MeshBase other_mesh) const
inherited

This tests for exactly-equal data in all the senses that a mathematician would care about (element connectivity, nodal coordinates), but in the senses a programmer would care about it allows for non-equal equivalence in some ways (we accept different Elem/Node addresses in memory) but not others (we do not accept different subclass types, nor even different Elem/Node ids).

Definition at line 212 of file mesh_base.C.

References libMesh::ParallelObject::comm(), libMesh::MeshBase::locally_equals(), and TIMPI::Communicator::min().

213 {
214  LOG_SCOPE("operator==()", "MeshBase");
215 
216  bool is_equal = this->locally_equals(other_mesh);
217  this->comm().min(is_equal);
218  return is_equal;
219 }
const Parallel::Communicator & comm() const
void min(const T &r, T &o, Request &req) const
bool locally_equals(const MeshBase &other_mesh) const
This behaves the same as operator==, but only for the local and ghosted aspects of the mesh; i...
Definition: mesh_base.C:222

◆ own_node()

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

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

Reimplemented from libMesh::MeshBase.

Definition at line 785 of file distributed_mesh.C.

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

786 {
787  // This had better be a node in our mesh
788  libmesh_assert(_nodes[n.id()] == &n);
789 
790  _nodes[n.id()] = nullptr;
791  _n_nodes--;
792 
793  n.set_id(DofObject::invalid_id);
794  n.processor_id() = this->processor_id();
795 
796  this->add_node(&n);
797 }
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
virtual Node * add_node(Node *n) override final
Add Node n to the end of the vertex array.
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:477
processor_id_type processor_id() const

◆ parallel_max_elem_id()

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

Definition at line 310 of file distributed_mesh.C.

References libMesh::DistributedMesh::_elements, libMesh::ParallelObject::comm(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and TIMPI::Communicator::max().

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

311 {
312  // This function must be run on all processors at once
313  parallel_object_only();
314 
315  dof_id_type max_local = 0;
316 
317  dofobject_container<Elem>::const_reverse_veclike_iterator
318  rit = _elements.rbegin();
319 
320  const dofobject_container<Elem>::const_reverse_veclike_iterator
321  rend = _elements.rend();
322 
323  // Look for the maximum element id. Search backwards through
324  // elements so we can break out early. Beware of nullptr entries that
325  // haven't yet been cleared from _elements.
326  for (; rit != rend; ++rit)
327  {
328  const DofObject *d = *rit;
329  if (d)
330  {
331  libmesh_assert(_elements[d->id()] == d);
332  max_local = d->id() + 1;
333  break;
334  }
335  }
336 
337  this->comm().max(max_local);
338  return max_local;
339 }
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.
void max(const T &r, T &o, Request &req) const
uint8_t dof_id_type
Definition: id_types.h:67

◆ parallel_max_node_id()

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

Definition at line 384 of file distributed_mesh.C.

References libMesh::DistributedMesh::_nodes, libMesh::ParallelObject::comm(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and TIMPI::Communicator::max().

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

385 {
386  // This function must be run on all processors at once
387  parallel_object_only();
388 
389  dof_id_type max_local = 0;
390 
391  dofobject_container<Node>::const_reverse_veclike_iterator
392  rit = _nodes.rbegin();
393 
394  const dofobject_container<Node>::const_reverse_veclike_iterator
395  rend = _nodes.rend();
396 
397  // Look for the maximum node id. Search backwards through
398  // nodes so we can break out early. Beware of nullptr entries that
399  // haven't yet been cleared from _nodes
400  for (; rit != rend; ++rit)
401  {
402  const DofObject *d = *rit;
403  if (d)
404  {
405  libmesh_assert(_nodes[d->id()] == d);
406  max_local = d->id() + 1;
407  break;
408  }
409  }
410 
411  this->comm().max(max_local);
412  return max_local;
413 }
const Parallel::Communicator & comm() const
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)
void max(const T &r, T &o, Request &req) const
uint8_t dof_id_type
Definition: id_types.h:67

◆ parallel_max_unique_id()

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

Implements libMesh::MeshBase.

Definition at line 344 of file distributed_mesh.C.

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

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

345 {
346  // This function must be run on all processors at once
347  parallel_object_only();
348 
349  unique_id_type max_local = std::max(_next_unique_id,
351  this->comm().max(max_local);
352  return max_local;
353 }
const Parallel::Communicator & comm() const
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
void max(const T &r, T &o, Request &req) const
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
uint8_t unique_id_type
Definition: id_types.h:86

◆ parallel_n_elem()

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

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

Implements libMesh::MeshBase.

Definition at line 297 of file distributed_mesh.C.

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

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

298 {
299  // This function must be run on all processors at once
300  parallel_object_only();
301 
302  dof_id_type n_local = this->n_local_elem();
303  this->comm().sum(n_local);
304  n_local += this->n_unpartitioned_elem();
305  return n_local;
306 }
void sum(T &r) const
const Parallel::Communicator & comm() const
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:533
dof_id_type n_local_elem() const
Definition: mesh_base.h:527
uint8_t dof_id_type
Definition: id_types.h:67

◆ parallel_n_nodes()

dof_id_type libMesh::DistributedMesh::parallel_n_nodes ( ) const
overridevirtualinherited
Returns
The number of nodes in the mesh.

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

Implements libMesh::MeshBase.

Definition at line 371 of file distributed_mesh.C.

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

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

372 {
373  // This function must be run on all processors at once
374  parallel_object_only();
375 
376  dof_id_type n_local = this->n_local_nodes();
377  this->comm().sum(n_local);
378  n_local += this->n_unpartitioned_nodes();
379  return n_local;
380 }
dof_id_type n_unpartitioned_nodes() const
Definition: mesh_base.h:427
void sum(T &r) const
dof_id_type n_local_nodes() const
Definition: mesh_base.h:421
const Parallel::Communicator & comm() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ partition() [1/2]

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

Call the default partitioner (currently metis_partition()).

Definition at line 1503 of file mesh_base.C.

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

Referenced by main(), libMesh::split_mesh(), ExtraIntegersTest::test_helper(), MappedSubdomainPartitionerTest::testMappedSubdomainPartitioner(), EquationSystemsTest::testRepartitionThenReinit(), and CheckpointIOTest::testSplitter().

1504 {
1505  // If we get here and we have unpartitioned elements, we need that
1506  // fixed.
1507  if (this->n_unpartitioned_elem() > 0)
1508  {
1509  libmesh_assert (partitioner().get());
1510  libmesh_assert (this->is_serial());
1511  partitioner()->partition (*this, n_parts);
1512  }
1513  // A nullptr partitioner or a skip_partitioning(true) call or a
1514  // skip_noncritical_partitioning(true) call means don't repartition;
1515  // skip_noncritical_partitioning() checks all these.
1516  else if (!skip_noncritical_partitioning())
1517  {
1518  partitioner()->partition (*this, n_parts);
1519  }
1520  else
1521  {
1522  // Adaptive coarsening may have "orphaned" nodes on processors
1523  // whose elements no longer share them. We need to check for
1524  // and possibly fix that.
1526 
1527  // Make sure locally cached partition count is correct
1528  this->recalculate_n_partitions();
1529 
1530  // Make sure any other locally cached data is correct
1531  this->update_post_partitioning();
1532  }
1533 }
void correct_node_proc_ids(MeshBase &)
Changes the processor ids on each node so be the same as the id of the lowest element touching that n...
Definition: mesh_tools.C:2219
bool skip_noncritical_partitioning() const
Definition: mesh_base.h:1216
virtual std::unique_ptr< Partitioner > & partitioner()
A partitioner to use at each prepare_for_use()
Definition: mesh_base.h:154
dof_id_type n_unpartitioned_elem() const
Definition: mesh_base.h:533
virtual bool is_serial() const
Definition: mesh_base.h:205
libmesh_assert(ctx)
unsigned int recalculate_n_partitions()
In a few (very rare) cases, the user may have manually tagged the elements with specific processor ID...
Definition: mesh_base.C:1545
virtual void update_post_partitioning()
Recalculate any cached data after elements and nodes have been repartitioned.
Definition: mesh_base.h:1154

◆ partition() [2/2]

void libMesh::MeshBase::partition ( )
inlineinherited

Definition at line 1139 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

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

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

◆ partitioner()

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

A partitioner to use at each prepare_for_use()

Definition at line 154 of file mesh_base.h.

References libMesh::MeshBase::_partitioner.

Referenced by main(), libMesh::MeshBase::partition(), libMesh::BoundaryInfo::sync(), MultiEvaluablePredTest::test(), MeshDeletionsTest::testDeleteElem(), and MappedSubdomainPartitionerTest::testMappedSubdomainPartitioner().

154 { return _partitioner; }
std::unique_ptr< Partitioner > _partitioner
A partitioner to use at each prepare_for_use().
Definition: mesh_base.h:1843

◆ point()

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

Implements libMesh::MeshBase.

Definition at line 417 of file distributed_mesh.C.

References libMesh::MeshBase::node_ref().

418 {
419  return this->node_ref(i);
420 }
virtual const Node & node_ref(const dof_id_type i) const
Definition: mesh_base.h:575

◆ post_dofobject_moves()

void libMesh::MeshBase::post_dofobject_moves ( MeshBase &&  other_mesh)
protectedinherited

Moves any superclass data (e.g.

GhostingFunctors that might rely on element and nodal data (which is managed by subclasses!) being already moved first.

Must be manually called in dofobject-managing subclass move operators.

Definition at line 1872 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::_default_ghosting, libMesh::MeshBase::_ghosting_functors, libMesh::MeshBase::_partitioner, and libMesh::MeshBase::_shared_functors.

Referenced by libMesh::ReplicatedMesh::operator=().

1873 {
1874  // Now that all the DofObject moving is done, we can move the GhostingFunctor objects
1875  // which include the _default_ghosting,_ghosting_functors and _shared_functors. We also need
1876  // to set the mesh object associated with these functors to the assignee mesh.
1877 
1878  // _default_ghosting
1879  _default_ghosting = std::move(other_mesh._default_ghosting);
1880  _default_ghosting->set_mesh(this);
1881 
1882  // _ghosting_functors
1883  _ghosting_functors = std::move(other_mesh._ghosting_functors);
1884 
1885  for (const auto gf : _ghosting_functors )
1886  {
1887  gf->set_mesh(this);
1888  }
1889 
1890  // _shared_functors
1891  _shared_functors = std::move(other_mesh._shared_functors);
1892 
1893  for (const auto & sf : _shared_functors )
1894  {
1895  (sf.second)->set_mesh(this);
1896  }
1897 
1898  // _constraint_rows
1899  _constraint_rows = std::move(other_mesh._constraint_rows);
1900 
1901  if (other_mesh.partitioner())
1902  _partitioner = std::move(other_mesh.partitioner());
1903 }
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
std::unique_ptr< Partitioner > _partitioner
A partitioner to use at each prepare_for_use().
Definition: mesh_base.h:1843
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > > _shared_functors
Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form...
Definition: mesh_base.h:1997
std::unique_ptr< GhostingFunctor > _default_ghosting
The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior...
Definition: mesh_base.h:1982

◆ prepare_for_use() [1/3]

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

Prepare a newly ecreated (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_data()

The argument to skip renumbering is now deprecated - to prevent a mesh from being renumbered, set allow_renumbering(false). The argument to skip finding neighbors is also deprecated. To prevent find_neighbors, set allow_find_neighbors(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 710 of file mesh_base.C.

References libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_renumbering(), and libMesh::MeshBase::prepare_for_use().

Referenced by LinearElasticityWithContact::add_contact_edge_elements(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshRefinement::coarsen_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), main(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::GMVIO::read(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::BoundaryInfo::sync(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), MeshDeletionsTest::testDeleteElem(), SystemsTest::testDofCouplingWithVarGroups(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshTriangulationTest::testEdgesMesh(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), MeshInputTest::testNemesisReadImpl(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), MeshInputTest::testTetgenIO(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), tetrahedralize_domain(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::MeshRefinement::uniformly_refine().

711 {
712  libmesh_deprecated();
713 
714  // We only respect the users wish if they tell us to skip renumbering. If they tell us not to
715  // skip renumbering but someone previously called allow_renumbering(false), then the latter takes
716  // precedence
717  if (skip_renumber_nodes_and_elements)
718  this->allow_renumbering(false);
719 
720  // We always accept the user's value for skip_find_neighbors, in contrast to skip_renumber
721  const bool old_allow_find_neighbors = this->allow_find_neighbors();
722  this->allow_find_neighbors(!skip_find_neighbors);
723 
724  this->prepare_for_use();
725 
726  this->allow_find_neighbors(old_allow_find_neighbors);
727 }
bool allow_find_neighbors() const
Definition: mesh_base.h:1181
void prepare_for_use()
Definition: mesh_base.C:742
bool allow_renumbering() const
Definition: mesh_base.h:1174

◆ prepare_for_use() [2/3]

void libMesh::MeshBase::prepare_for_use ( const bool  skip_renumber_nodes_and_elements)
inherited

Definition at line 729 of file mesh_base.C.

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

730 {
731  libmesh_deprecated();
732 
733  // We only respect the users wish if they tell us to skip renumbering. If they tell us not to
734  // skip renumbering but someone previously called allow_renumbering(false), then the latter takes
735  // precedence
736  if (skip_renumber_nodes_and_elements)
737  this->allow_renumbering(false);
738 
739  this->prepare_for_use();
740 }
void prepare_for_use()
Definition: mesh_base.C:742
bool allow_renumbering() const
Definition: mesh_base.h:1174

◆ prepare_for_use() [3/3]

void libMesh::MeshBase::prepare_for_use ( )
inherited

Definition at line 742 of file mesh_base.C.

References libMesh::MeshBase::_allow_remote_element_removal, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_skip_find_neighbors, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear_point_locator(), libMesh::ParallelObject::comm(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::MeshBase::find_neighbors(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshBase::partition(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::MeshBase::reinit_ghosting_functors(), libMesh::MeshBase::remove_orphaned_nodes(), libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::MeshBase::skip_partitioning(), and libMesh::MeshBase::update_parallel_id_counts().

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

743 {
744  LOG_SCOPE("prepare_for_use()", "MeshBase");
745 
746  parallel_object_only();
747 
748  libmesh_assert(this->comm().verify(this->is_serial()));
749 
750  // A distributed mesh may have processors with no elements (or
751  // processors with no elements of higher dimension, if we ever
752  // support mixed-dimension meshes), but we want consistent
753  // mesh_dimension anyways.
754  //
755  // cache_elem_data() should get the elem_dimensions() and
756  // mesh_dimension() correct later, and we don't need it earlier.
757 
758 
759  // Renumber the nodes and elements so that they in contiguous
760  // blocks. By default, _skip_renumber_nodes_and_elements is false.
761  //
762  // Instances where you if prepare_for_use() should not renumber the nodes
763  // and elements include reading in e.g. an xda/r or gmv file. In
764  // this case, the ordering of the nodes may depend on an accompanying
765  // solution, and the node ordering cannot be changed.
766 
767 
768  // Mesh modification operations might not leave us with consistent
769  // id counts, or might leave us with orphaned nodes we're no longer
770  // using, but our partitioner might need that consistency and/or
771  // might be confused by orphaned nodes.
774  else
775  {
776  this->remove_orphaned_nodes();
778  }
779 
780  // Let all the elements find their neighbors
782  this->find_neighbors();
783 
784  // The user may have set boundary conditions. We require that the
785  // boundary conditions were set consistently. Because we examine
786  // neighbors when evaluating non-raw boundary condition IDs, this
787  // assert is only valid when our neighbor links are in place.
788 #ifdef DEBUG
790 #endif
791 
792  // Search the mesh for all the dimensions of the elements
793  // and cache them.
794  this->cache_elem_data();
795 
796  // Search the mesh for elements that have a neighboring element
797  // of dim+1 and set that element as the interior parent
798  this->detect_interior_parents();
799 
800  // Fix up node unique ids in case mesh generation code didn't take
801  // exceptional care to do so.
802  // MeshCommunication().make_node_unique_ids_parallel_consistent(*this);
803 
804  // We're going to still require that mesh generation code gets
805  // element unique ids consistent.
806 #if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
808 #endif
809 
810  // Reset our PointLocator. Any old locator is invalidated any time
811  // the elements in the underlying elements in the mesh have changed,
812  // so we clear it here.
813  this->clear_point_locator();
814 
815  // Allow our GhostingFunctor objects to reinit if necessary.
816  // Do this before partitioning and redistributing, and before
817  // deleting remote elements.
818  this->reinit_ghosting_functors();
819 
820  // Partition the mesh unless *all* partitioning is to be skipped.
821  // If only noncritical partitioning is to be skipped, the
822  // partition() call will still check for orphaned nodes.
823  if (!skip_partitioning())
824  this->partition();
825 
826  // If we're using DistributedMesh, we'll probably want it
827  // parallelized.
829  this->delete_remote_elements();
830 
831  // Much of our boundary info may have been for now-remote parts of the mesh,
832  // in which case we don't want to keep local copies of data meant to be
833  // local. On the other hand we may have deleted, or the user may have added in
834  // a distributed fashion, boundary data that is meant to be global. So we
835  // handle both of those scenarios here
837 
840 
841  // The mesh is now prepared for use.
842  _is_prepared = true;
843 
844 #ifdef DEBUG
846 #ifdef LIBMESH_ENABLE_UNIQUE_ID
848 #endif
849 #endif
850 }
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868
void remove_orphaned_nodes()
Removes any orphaned nodes, nodes not connected to any elements.
Definition: mesh_base.C:690
void detect_interior_parents()
Search the mesh for elements that have a neighboring element of dim+1 and set that element as the int...
Definition: mesh_base.C:1729
const Parallel::Communicator & comm() const
bool _allow_remote_element_removal
If this is false then even on DistributedMesh remote elements will not be deleted during mesh prepara...
Definition: mesh_base.h:1881
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
virtual bool is_serial() const
Definition: mesh_base.h:205
virtual void find_neighbors(const bool reset_remote_elements=false, const bool reset_current_list=true)=0
Locate element face (edge in 2D) neighbors.
virtual void update_parallel_id_counts()=0
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors...
void cache_elem_data()
Definition: mesh_base.C:1662
void clear_point_locator()
Releases the current PointLocator object.
Definition: mesh_base.C:1598
libmesh_assert(ctx)
void libmesh_assert_valid_boundary_ids(const MeshBase &mesh)
A function for verifying that boundary condition ids match across processors.
Definition: mesh_tools.C:1534
bool _skip_find_neighbors
If this is true then we will skip find_neighbors in prepare_for_use.
Definition: mesh_base.h:1873
void regenerate_id_sets()
Clears and regenerates the cached sets of ids.
bool skip_partitioning() const
Definition: mesh_base.h:1233
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820
virtual void delete_remote_elements()
When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local ele...
Definition: mesh_base.h:247
void reinit_ghosting_functors()
Loops over ghosting functors and calls mesh_reinit()
Definition: mesh_base.C:853
void libmesh_assert_valid_unique_ids(const MeshBase &mesh)
A function for verifying that unique ids match across processors.
Definition: mesh_tools.C:1732
virtual void renumber_nodes_and_elements()=0
After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contigu...

◆ print_info()

void libMesh::MeshBase::print_info ( std::ostream &  os = libMesh::out,
const unsigned int  verbosity = 0,
const bool  global = true 
) const
inherited

Prints relevant information about the mesh.

Take note of the docstring for get_info() for more information pretaining to the verbosity and global parameters.

Definition at line 1489 of file mesh_base.C.

References libMesh::MeshBase::get_info().

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

1490 {
1491  os << this->get_info(verbosity, global)
1492  << std::endl;
1493 }
std::string get_info(const unsigned int verbosity=0, const bool global=true) const
Definition: mesh_base.C:1022

◆ processor_id()

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

Definition at line 114 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), 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::RBConstruction::compute_max_error_bound(), 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::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), 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::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), 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::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

◆ query_elem_ptr() [1/2]

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

Implements libMesh::MeshBase.

Definition at line 500 of file distributed_mesh.C.

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

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

501 {
502  auto it = _elements.find(i);
503  if (it != _elements.end())
504  {
505  const Elem * e = *it;
506  libmesh_assert (!e || e->id() == i);
507  return e;
508  }
509 
510  return nullptr;
511 }
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.

◆ query_elem_ptr() [2/2]

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

Implements libMesh::MeshBase.

Definition at line 516 of file distributed_mesh.C.

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

517 {
518  auto it = _elements.find(i);
519  if (it != _elements.end())
520  {
521  Elem * e = _elements[i];
522  libmesh_assert (!e || e->id() == i);
523  return e;
524  }
525 
526  return nullptr;
527 }
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.

◆ query_node_ptr() [1/2]

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

Implements libMesh::MeshBase.

Definition at line 446 of file distributed_mesh.C.

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

447 {
448  auto it = _nodes.find(i);
449  if (it != _nodes.end())
450  {
451  const Node * n = *it;
452  libmesh_assert (!n || n->id() == i);
453  return n;
454  }
455 
456  return nullptr;
457 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ query_node_ptr() [2/2]

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

Implements libMesh::MeshBase.

Definition at line 462 of file distributed_mesh.C.

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

463 {
464  auto it = _nodes.find(i);
465  if (it != _nodes.end())
466  {
467  Node * n = *it;
468  libmesh_assert (!n || n->id() == i);
469  return n;
470  }
471 
472  return nullptr;
473 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ read()

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

Reads the file specified by name.

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

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

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

Implements libMesh::MeshBase.

Definition at line 1221 of file unstructured_mesh.C.

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

Referenced by ExtraIntegersTest::checkpoint_helper(), main(), ExtraIntegersTest::test_helper(), SlitMeshRefinedSystemTest::testRestart(), and WriteElemsetData::testWriteImpl().

1225 {
1226  // Set the skip_renumber_nodes_and_elements flag on all processors
1227  // if necessary.
1228  // This ensures that renumber_nodes_and_elements is *not* called
1229  // during prepare_for_use() for certain types of mesh files.
1230  // This is required in cases where there is an associated solution
1231  // file which expects a certain ordering of the nodes.
1232  if (name.rfind(".gmv") == name.size() - 4)
1233  this->allow_renumbering(false);
1234 
1235  NameBasedIO(*this).read(name);
1236 
1237  if (skip_renumber_nodes_and_elements)
1238  {
1239  // Use MeshBase::allow_renumbering() yourself instead.
1240  libmesh_deprecated();
1241  this->allow_renumbering(false);
1242  }
1243 
1244  // Done reading the mesh. Now prepare it for use.
1245  const bool old_allow_find_neighbors = this->allow_find_neighbors();
1246  this->allow_find_neighbors(!skip_find_neighbors);
1247  this->prepare_for_use();
1248  this->allow_find_neighbors(old_allow_find_neighbors);
1249 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
This class supports simple reads and writes in any libMesh-supported format, by dispatching to one of...
Definition: namebased_io.h:44
virtual void read(const std::string &mesh_file) override
This method implements reading a mesh from a specified file.
Definition: namebased_io.C:80
bool allow_find_neighbors() const
Definition: mesh_base.h:1181
void prepare_for_use()
Definition: mesh_base.C:742
bool allow_renumbering() const
Definition: mesh_base.h:1174

◆ recalculate_n_partitions()

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

In a few (very rare) cases, the user may have manually tagged the elements with specific processor IDs by hand, without using a partitioner.

In this case, the Mesh will not know that the total number of partitions, _n_parts, has changed, unless you call this function. This is an O(N active elements) calculation. The return value is the number of partitions, and _n_parts is also set by this function.

Definition at line 1545 of file mesh_base.C.

References libMesh::MeshBase::_n_parts, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

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

1546 {
1547  // This requires an inspection on every processor
1548  parallel_object_only();
1549 
1550  unsigned int max_proc_id=0;
1551 
1552  for (const auto & elem : this->active_local_element_ptr_range())
1553  max_proc_id = std::max(max_proc_id, static_cast<unsigned int>(elem->processor_id()));
1554 
1555  // The number of partitions is one more than the max processor ID.
1556  _n_parts = max_proc_id+1;
1557 
1558  this->comm().max(_n_parts);
1559 
1560  return _n_parts;
1561 }
const Parallel::Communicator & comm() const
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802
void max(const T &r, T &o, Request &req) const

◆ redistribute()

void libMesh::DistributedMesh::redistribute ( )
overridevirtualinherited

Redistribute elements between processors.

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

Reimplemented from libMesh::MeshBase.

Definition at line 1039 of file distributed_mesh.C.

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

1040 {
1041  // If this is a truly parallel mesh, go through the redistribution/gather/delete remote steps
1042  if (!this->is_serial())
1043  {
1044  // Construct a MeshCommunication object to actually redistribute the nodes
1045  // and elements according to the partitioner, and then to re-gather the neighbors.
1046  MeshCommunication mc;
1047  mc.redistribute(*this);
1048 
1049  this->update_parallel_id_counts();
1050 
1051  // We ought to still have valid neighbor links; we communicate
1052  // them for newly-redistributed elements
1053  // this->find_neighbors();
1054 
1055  // Is this necessary? If we are called from prepare_for_use(), this will be called
1056  // anyway... but users can always call partition directly, in which case we do need
1057  // to call delete_remote_elements()...
1058  //
1059  // Regardless of whether it's necessary, it isn't safe. We
1060  // haven't communicated new node processor_ids yet, and we can't
1061  // delete nodes until we do.
1062  // this->delete_remote_elements();
1063  }
1064  else
1065  // The base class can handle non-distributed things, like
1066  // notifying any GhostingFunctors of changes
1068 }
virtual void update_parallel_id_counts() override
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors...
friend class MeshCommunication
Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.
Definition: mesh_base.h:2039
virtual bool is_serial() const override final
virtual void redistribute()
Redistribute elements between processors.
Definition: mesh_base.C:925

◆ reinit_ghosting_functors()

void libMesh::MeshBase::reinit_ghosting_functors ( )
inherited

Loops over ghosting functors and calls mesh_reinit()

Definition at line 853 of file mesh_base.C.

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

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

854 {
855  for (auto & gf : _ghosting_functors)
856  {
857  libmesh_assert(gf);
858  gf->mesh_reinit();
859  }
860 }
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
libmesh_assert(ctx)

◆ remove_ghosting_functor()

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

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

Definition at line 888 of file mesh_base.C.

References libMesh::MeshBase::_ghosting_functors, and libMesh::MeshBase::_shared_functors.

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

889 {
890  _ghosting_functors.erase(&ghosting_functor);
891 
892  auto it = _shared_functors.find(&ghosting_functor);
893  if (it != _shared_functors.end())
894  _shared_functors.erase(it);
895 }
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > > _shared_functors
Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form...
Definition: mesh_base.h:1997

◆ remove_orphaned_nodes()

void libMesh::MeshBase::remove_orphaned_nodes ( )
inherited

Removes any orphaned nodes, nodes not connected to any elements.

Typically done automatically in prepare_for_use

Definition at line 690 of file mesh_base.C.

References libMesh::MeshBase::delete_node().

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

691 {
692  LOG_SCOPE("remove_orphaned_nodes()", "MeshBase");
693 
694  // Will hold the set of nodes that are currently connected to elements
695  std::unordered_set<Node *> connected_nodes;
696 
697  // Loop over the elements. Find which nodes are connected to at
698  // least one of them.
699  for (const auto & element : this->element_ptr_range())
700  for (auto & n : element->node_ref_range())
701  connected_nodes.insert(&n);
702 
703  for (const auto & node : this->node_ptr_range())
704  if (!connected_nodes.count(node))
705  this->delete_node(node);
706 }
virtual void delete_node(Node *n)=0
Removes the Node n from the mesh.

◆ renumber_dof_objects()

template<typename T >
dof_id_type libMesh::DistributedMesh::renumber_dof_objects ( dofobject_container< T > &  objects)
inherited

Renumber a parallel objects container.

Returns
The smallest globally unused id for that container.

Definition at line 1200 of file distributed_mesh.C.

References TIMPI::Communicator::allgather(), libMesh::mapvector< Val, index_t >::begin(), libMesh::ParallelObject::comm(), libMesh::mapvector< Val, index_t >::end(), libMesh::mapvector< Val, index_t >::erase(), libMesh::index_range(), libMesh::DofObject::invalid_processor_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::ParallelObject::n_processors(), libMesh::MeshTools::Subdivision::next, libMesh::DistributedMesh::pid, and libMesh::ParallelObject::processor_id().

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

1201 {
1202  // This function must be run on all processors at once
1203  parallel_object_only();
1204 
1205  typedef typename dofobject_container<T>::veclike_iterator object_iterator;
1206 
1207  // In parallel we may not know what objects other processors have.
1208  // Start by figuring out how many
1209  dof_id_type unpartitioned_objects = 0;
1210 
1211  std::unordered_map<processor_id_type, dof_id_type>
1212  ghost_objects_from_proc;
1213 
1214  object_iterator it = objects.begin();
1215  object_iterator end = objects.end();
1216 
1217  while (it != end)
1218  {
1219  T * obj = *it;
1220 
1221  // Remove any nullptr container entries while we're here.
1222  if (!obj)
1223  it = objects.erase(it);
1224  else
1225  {
1226  processor_id_type obj_procid = obj->processor_id();
1227  if (obj_procid == DofObject::invalid_processor_id)
1228  unpartitioned_objects++;
1229  else
1230  ghost_objects_from_proc[obj_procid]++;
1231 
1232  // Finally, increment the iterator
1233  ++it;
1234  }
1235  }
1236 
1237  std::vector<dof_id_type> objects_on_proc(this->n_processors(), 0);
1238  auto this_it = ghost_objects_from_proc.find(this->processor_id());
1239  this->comm().allgather
1240  ((this_it == ghost_objects_from_proc.end()) ?
1241  dof_id_type(0) : this_it->second, objects_on_proc);
1242 
1243 #ifndef NDEBUG
1244  libmesh_assert(this->comm().verify(unpartitioned_objects));
1245  for (processor_id_type p=0, np=this->n_processors(); p != np; ++p)
1246  if (ghost_objects_from_proc.count(p))
1247  libmesh_assert_less_equal (ghost_objects_from_proc[p], objects_on_proc[p]);
1248  else
1249  libmesh_assert_less_equal (0, objects_on_proc[p]);
1250 #endif
1251 
1252  // We'll renumber objects in blocks by processor id
1253  std::vector<dof_id_type> first_object_on_proc(this->n_processors());
1254  for (processor_id_type i=1, np=this->n_processors(); i != np; ++i)
1255  first_object_on_proc[i] = first_object_on_proc[i-1] +
1256  objects_on_proc[i-1];
1257  dof_id_type next_id = first_object_on_proc[this->processor_id()];
1258  dof_id_type first_free_id =
1259  first_object_on_proc[this->n_processors()-1] +
1260  objects_on_proc[this->n_processors()-1] +
1261  unpartitioned_objects;
1262 
1263  // First set new local object ids and build request sets
1264  // for non-local object ids
1265 
1266  // Request sets to send to each processor
1267  std::map<processor_id_type, std::vector<dof_id_type>>
1268  requested_ids;
1269 
1270  // We know how many objects live on each processor, so reserve() space for
1271  // each.
1272  auto ghost_end = ghost_objects_from_proc.end();
1273  for (auto p : make_range(this->n_processors()))
1274  if (p != this->processor_id())
1275  {
1276  const auto p_it = ghost_objects_from_proc.find(p);
1277  if (p_it != ghost_end)
1278  requested_ids[p].reserve(p_it->second);
1279  }
1280 
1281  end = objects.end();
1282  for (it = objects.begin(); it != end; ++it)
1283  {
1284  T * obj = *it;
1285  if (!obj)
1286  continue;
1287  if (obj->processor_id() == this->processor_id())
1288  obj->set_id(next_id++);
1289  else if (obj->processor_id() != DofObject::invalid_processor_id)
1290  requested_ids[obj->processor_id()].push_back(obj->id());
1291  }
1292 
1293  // Next set ghost object ids from other processors
1294 
1295  auto gather_functor =
1296  [
1297 #ifndef NDEBUG
1298  this,
1299  &first_object_on_proc,
1300  &objects_on_proc,
1301 #endif
1302  &objects]
1303  (processor_id_type, const std::vector<dof_id_type> & ids,
1304  std::vector<dof_id_type> & new_ids)
1305  {
1306  std::size_t ids_size = ids.size();
1307  new_ids.resize(ids_size);
1308 
1309  for (std::size_t i=0; i != ids_size; ++i)
1310  {
1311  T * obj = objects[ids[i]];
1312  libmesh_assert(obj);
1313  libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
1314  new_ids[i] = obj->id();
1315 
1316  libmesh_assert_greater_equal (new_ids[i],
1317  first_object_on_proc[this->processor_id()]);
1318  libmesh_assert_less (new_ids[i],
1319  first_object_on_proc[this->processor_id()] +
1320  objects_on_proc[this->processor_id()]);
1321  }
1322  };
1323 
1324  auto action_functor =
1325  [
1326 #ifndef NDEBUG
1327  &first_object_on_proc,
1328  &objects_on_proc,
1329 #endif
1330  &objects]
1331  (processor_id_type libmesh_dbg_var(pid),
1332  const std::vector<dof_id_type> & ids,
1333  const std::vector<dof_id_type> & data)
1334  {
1335  // Copy the id changes we've now been informed of
1336  for (auto i : index_range(ids))
1337  {
1338  T * obj = objects[ids[i]];
1339  libmesh_assert (obj);
1340  libmesh_assert_equal_to (obj->processor_id(), pid);
1341  libmesh_assert_greater_equal (data[i],
1342  first_object_on_proc[pid]);
1343  libmesh_assert_less (data[i],
1344  first_object_on_proc[pid] +
1345  objects_on_proc[pid]);
1346  obj->set_id(data[i]);
1347  }
1348  };
1349 
1350  const dof_id_type * ex = nullptr;
1351  Parallel::pull_parallel_vector_data
1352  (this->comm(), requested_ids, gather_functor, action_functor, ex);
1353 
1354 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1355  auto unique_gather_functor =
1356  [
1357 #ifndef NDEBUG
1358  this,
1359 #endif
1360  &objects]
1361  (processor_id_type, const std::vector<dof_id_type> & ids,
1362  std::vector<unique_id_type> & data)
1363  {
1364  std::size_t ids_size = ids.size();
1365  data.resize(ids_size);
1366 
1367  for (std::size_t i=0; i != ids_size; ++i)
1368  {
1369  T * obj = objects[ids[i]];
1370  libmesh_assert(obj);
1371  libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
1372  data[i] = obj->valid_unique_id() ? obj->unique_id() : DofObject::invalid_unique_id;
1373  }
1374  };
1375 
1376  auto unique_action_functor =
1377  [&objects]
1378  (processor_id_type libmesh_dbg_var(pid),
1379  const std::vector<dof_id_type> & ids,
1380  const std::vector<unique_id_type> & data)
1381  {
1382  for (auto i : index_range(ids))
1383  {
1384  T * obj = objects[ids[i]];
1385  libmesh_assert (obj);
1386  libmesh_assert_equal_to (obj->processor_id(), pid);
1387  if (!obj->valid_unique_id() && data[i] != DofObject::invalid_unique_id)
1388  obj->set_unique_id(data[i]);
1389  }
1390  };
1391 
1392  const unique_id_type * unique_ex = nullptr;
1393  Parallel::pull_parallel_vector_data
1394  (this->comm(), requested_ids, unique_gather_functor,
1395  unique_action_functor, unique_ex);
1396 #endif
1397 
1398  // Next set unpartitioned object ids
1399  next_id = 0;
1400  for (auto i : make_range(this->n_processors()))
1401  next_id += objects_on_proc[i];
1402  for (it = objects.begin(); it != end; ++it)
1403  {
1404  T * obj = *it;
1405  if (!obj)
1406  continue;
1407  if (obj->processor_id() == DofObject::invalid_processor_id)
1408  obj->set_id(next_id++);
1409  }
1410 
1411  // Finally shuffle around objects so that container indices
1412  // match ids
1413  it = objects.begin();
1414  end = objects.end();
1415  while (it != end)
1416  {
1417  T * obj = *it;
1418  if (obj) // don't try shuffling already-nullptr entries
1419  {
1420  T * next = objects[obj->id()];
1421  // If we have to move this object
1422  if (next != obj)
1423  {
1424  // nullptr out its original position for now
1425  // (our shuffling may put another object there shortly)
1426  *it = nullptr;
1427 
1428  // There may already be another object with this id that
1429  // needs to be moved itself
1430  while (next)
1431  {
1432  // We shouldn't be trying to give two objects the
1433  // same id
1434  libmesh_assert_not_equal_to (next->id(), obj->id());
1435  objects[obj->id()] = obj;
1436  obj = next;
1437  next = objects[obj->id()];
1438  }
1439  objects[obj->id()] = obj;
1440  }
1441  }
1442 
1443  // Remove any container entries that were left as nullptr.
1444  if (!obj)
1445  it = objects.erase(it);
1446  else
1447  ++it;
1448  }
1449 
1450  return first_free_id;
1451 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
const Parallel::Communicator & comm() const
uint8_t processor_id_type
Definition: id_types.h:104
uint8_t processor_id_type
processor_id_type n_processors() const
static const unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
static const unsigned int next[3]
A lookup table for the increment modulo 3 operation, for iterating through the three nodes per elemen...
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
processor_id_type processor_id() const
uint8_t unique_id_type
Definition: id_types.h:86
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
uint8_t dof_id_type
Definition: id_types.h:67

◆ renumber_elem()

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

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

No element with the id new_id should already exist.

Implements libMesh::MeshBase.

Definition at line 746 of file distributed_mesh.C.

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

Referenced by ExodusTest< elem_type >::meshes_equal_enough().

748 {
749  Elem * el = _elements[old_id];
750  libmesh_assert (el);
751  libmesh_assert_equal_to (el->id(), old_id);
752 
753  el->set_id(new_id);
754  libmesh_assert (!_elements[new_id]);
755  _elements[new_id] = el;
756  _elements.erase(old_id);
757 }
libmesh_assert(ctx)
dofobject_container< Elem > _elements
The elements in the mesh.

◆ renumber_node()

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

Changes the id of node old_id, both by changing node(old_id)->id() and by moving node(old_id) in the mesh's internal container.

No element with the id new_id should already exist.

Implements libMesh::MeshBase.

Definition at line 955 of file distributed_mesh.C.

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

Referenced by ExodusTest< elem_type >::meshes_equal_enough().

957 {
958  Node * nd = _nodes[old_id];
959  libmesh_assert (nd);
960  libmesh_assert_equal_to (nd->id(), old_id);
961 
962  // If we have nodes shipped to this processor for NodeConstraints
963  // use, then those nodes will exist in _nodes, but may not be
964  // locatable via a TopologyMap due to the insufficiency of elements
965  // connecting to them. If local refinement then wants to create a
966  // *new* node in the same location, it will initially get a temporary
967  // id, and then make_node_ids_parallel_consistent() will try to move
968  // it to the canonical id. We need to account for this case to
969  // avoid false positives and memory leaks.
970 #ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
971  if (_nodes[new_id])
972  {
973  libmesh_assert_equal_to (*(Point *)_nodes[new_id],
974  *(Point *)_nodes[old_id]);
975  _nodes.erase(new_id);
976  }
977 #else
978  // If we aren't shipping nodes for NodeConstraints, there should be
979  // no reason for renumbering one node onto another.
980  libmesh_assert (!_nodes[new_id]);
981 #endif
982  _nodes[new_id] = nd;
983  nd->set_id(new_id);
984 
985  _nodes.erase(old_id);
986 }
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
libmesh_assert(ctx)

◆ renumber_nodes_and_elements()

void libMesh::DistributedMesh::renumber_nodes_and_elements ( )
overridevirtualinherited

Remove nullptr elements from arrays.

Implements libMesh::MeshBase.

Definition at line 1454 of file distributed_mesh.C.

References libMesh::MeshBase::_constraint_rows, libMesh::DistributedMesh::_deleted_coarse_elements, libMesh::DistributedMesh::_elements, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_nodes, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::ParallelObject::comm(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), TIMPI::Communicator::max(), libMesh::DistributedMesh::max_elem_id(), libMesh::DistributedMesh::max_node_id(), libMesh::DistributedMesh::n_elem(), libMesh::DistributedMesh::n_nodes(), libMesh::MeshBase::node_ref(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::DistributedMesh::pid, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::BoundaryInfo::remove(), libMesh::DistributedMesh::renumber_dof_objects(), and libMesh::DistributedMesh::update_parallel_id_counts().

1455 {
1456  parallel_object_only();
1457 
1458 #ifdef DEBUG
1459  // Make sure our ids and flags are consistent
1463 #endif
1464 
1465  LOG_SCOPE("renumber_nodes_and_elements()", "DistributedMesh");
1466 
1467  // Nodes not connected to any elements, and nullptr node entries
1468  // in our container, should be deleted. But wait! If we've deleted coarse
1469  // local elements on some processor, other processors might have ghosted
1470  // nodes from it that are now no longer connected to any elements on it, but
1471  // that are connected to their own semilocal elements. We'll have to
1472  // communicate to ascertain if that's the case.
1474 
1475  // What used nodes do we see on our proc?
1476  std::set<dof_id_type> used_nodes;
1477 
1478  // What used node info should we send from our proc? Could we take ownership
1479  // of each node if we needed to?
1480  std::map<processor_id_type, std::map<dof_id_type, bool>>
1481  used_nodes_on_proc;
1482 
1483  // flag the nodes we need
1484  for (auto & elem : this->element_ptr_range())
1485  for (const Node & node : elem->node_ref_range())
1486  {
1487  const dof_id_type n = node.id();
1488  used_nodes.insert(n);
1490  {
1491  const processor_id_type p = node.processor_id();
1492  if (p != this->processor_id())
1493  {
1494  auto & used_nodes_on_p = used_nodes_on_proc[p];
1495  if (elem->processor_id() == this->processor_id())
1496  used_nodes_on_p[n] = true;
1497  else
1498  if (!used_nodes_on_p.count(n))
1499  used_nodes_on_p[n] = false;
1500  }
1501  }
1502  }
1503 
1505  {
1506  // "unsigned char" == "bool, but MPI::BOOL is iffy to use"
1507  typedef unsigned char boolish;
1508  std::map<processor_id_type, std::vector<std::pair<dof_id_type, boolish>>>
1509  used_nodes_on_proc_vecs;
1510  for (auto & [pid, nodemap] : used_nodes_on_proc)
1511  used_nodes_on_proc_vecs[pid].assign(nodemap.begin(), nodemap.end());
1512 
1513  std::map<dof_id_type,processor_id_type> repartitioned_node_pids;
1514  std::map<processor_id_type, std::set<dof_id_type>>
1515  repartitioned_node_sets_to_push;
1516 
1517  auto ids_action_functor =
1518  [&used_nodes, &repartitioned_node_pids,
1519  &repartitioned_node_sets_to_push]
1521  const std::vector<std::pair<dof_id_type, boolish>> & ids_and_bools)
1522  {
1523  for (auto [n, sender_could_become_owner] : ids_and_bools)
1524  {
1525  // If we don't see a use for our own node, but someone
1526  // else does, better figure out who should own it next.
1527  if (!used_nodes.count(n))
1528  {
1529  auto it = repartitioned_node_pids.find(n);
1530  if (sender_could_become_owner)
1531  {
1532  if (it != repartitioned_node_pids.end() &&
1533  pid < it->second)
1534  it->second = pid;
1535  else
1536  repartitioned_node_pids[n] = pid;
1537  }
1538  else
1539  if (it == repartitioned_node_pids.end())
1540  repartitioned_node_pids[n] =
1542 
1543  repartitioned_node_sets_to_push[pid].insert(n);
1544  }
1545  }
1546  };
1547 
1548  // We need two pushes instead of a pull here because we need to
1549  // know *all* the queries for a particular node before we can
1550  // respond to *any* of them.
1551  Parallel::push_parallel_vector_data
1552  (this->comm(), used_nodes_on_proc_vecs, ids_action_functor);
1553 
1554  // Repartition (what used to be) our own nodes first
1555  for (auto & [n, p] : repartitioned_node_pids)
1556  {
1557  Node & node = this->node_ref(n);
1558  libmesh_assert_equal_to(node.processor_id(), this->processor_id());
1559  libmesh_assert_not_equal_to_msg(p, DofObject::invalid_processor_id, "Node " << n << " is lost?");
1560  node.processor_id() = p;
1561  }
1562 
1563  // Then push to repartition others' ghosted copies.
1564 
1565  std::map<processor_id_type, std::vector<std::pair<dof_id_type,processor_id_type>>>
1566  repartitioned_node_vecs;
1567 
1568  for (auto & [p, nodeset] : repartitioned_node_sets_to_push)
1569  {
1570  auto & rn_vec = repartitioned_node_vecs[p];
1571  for (auto n : nodeset)
1572  rn_vec.emplace_back(n, repartitioned_node_pids[n]);
1573  }
1574 
1575  auto repartition_node_functor =
1576  [this]
1577  (processor_id_type libmesh_dbg_var(pid),
1578  const std::vector<std::pair<dof_id_type, processor_id_type>> & ids_and_pids)
1579  {
1580  for (auto [n, p] : ids_and_pids)
1581  {
1582  libmesh_assert_not_equal_to(p, DofObject::invalid_processor_id);
1583  Node & node = this->node_ref(n);
1584  libmesh_assert_equal_to(node.processor_id(), pid);
1585  node.processor_id() = p;
1586  }
1587  };
1588 
1589  Parallel::push_parallel_vector_data
1590  (this->comm(), repartitioned_node_vecs, repartition_node_functor);
1591  }
1592 
1593  _deleted_coarse_elements = false;
1594 
1595  // Nodes not connected to any local elements, and nullptr node entries
1596  // in our container, are deleted
1597  {
1598  node_iterator_imp it = _nodes.begin();
1599  node_iterator_imp end = _nodes.end();
1600 
1601  while (it != end)
1602  {
1603  Node * nd = *it;
1604  if (!nd)
1605  it = _nodes.erase(it);
1606  else if (!used_nodes.count(nd->id()))
1607  {
1608  // remove any boundary information associated with
1609  // this node
1610  this->get_boundary_info().remove (nd);
1611  _constraint_rows.erase(nd);
1612 
1613  // delete the node
1614  delete nd;
1615 
1616  it = _nodes.erase(it);
1617  }
1618  else
1619  ++it;
1620  }
1621  }
1622 
1624  {
1625  this->update_parallel_id_counts();
1626  return;
1627  }
1628 
1629  // Finally renumber all the elements
1630  _n_elem = this->renumber_dof_objects (this->_elements);
1631 
1632  // and all the remaining nodes
1633  _n_nodes = this->renumber_dof_objects (this->_nodes);
1634 
1635  // And figure out what IDs we should use when adding new nodes and
1636  // new elements
1637  this->update_parallel_id_counts();
1638 
1639  // Make sure our caches are up to date and our
1640  // DofObjects are well packed
1641 #ifdef DEBUG
1642  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
1643  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
1644  const dof_id_type pmax_node_id = this->parallel_max_node_id();
1645  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
1646  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
1647  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
1648  libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
1649  libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
1650 
1651  // Make sure our ids and flags are consistent
1654 
1655  // And make sure we've made our numbering monotonic
1657 #endif
1658 }
virtual void update_parallel_id_counts() override
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors...
virtual dof_id_type parallel_n_nodes() const override
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868
virtual void libmesh_assert_valid_parallel_ids() const override
Verify id and processor_id consistency of our elements and nodes containers.
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
virtual dof_id_type n_nodes() const override final
void remove(const Node *node)
Removes the boundary conditions associated with node node, if any exist.
constraint_rows_type _constraint_rows
Definition: mesh_base.h:2009
const Parallel::Communicator & comm() const
void libmesh_assert_valid_parallel_flags() const
Verify refinement_flag and p_refinement_flag consistency of our elements containers.
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
dofobject_container< Node >::veclike_iterator node_iterator_imp
Typedefs for the container implementation.
void libmesh_assert_valid_parallel_p_levels() const
Verify p_level consistency of our elements containers.
processor_id_type pid unsigned int level std::set< subdomain_id_type > ss const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dofobject_container< Node > _nodes
Move node and elements from a DistributedMesh.
uint8_t processor_id_type
virtual dof_id_type parallel_n_elem() const override
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
dof_id_type parallel_max_node_id() const
dofobject_container< Elem > _elements
The elements in the mesh.
void max(const T &r, T &o, Request &req) const
virtual dof_id_type max_node_id() const override final
virtual const Node & node_ref(const dof_id_type i) const
Definition: mesh_base.h:575
virtual dof_id_type n_elem() const override final
processor_id_type processor_id() const
virtual dof_id_type max_elem_id() const override final
bool _deleted_coarse_elements
A boolean remembering whether we&#39;ve recently deleted top-level elements or not.
dof_id_type renumber_dof_objects(dofobject_container< T > &)
Renumber a parallel objects container.
dof_id_type parallel_max_elem_id() const
uint8_t dof_id_type
Definition: id_types.h:67
void libmesh_assert_valid_elem_ids(const MeshBase &mesh)
A function for verifying that ids and processor assignment of elements are correctly sorted (monotone...
Definition: mesh_tools.C:1170

◆ reserve_elem()

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

Reserves space for a known number of elements.

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

Implements libMesh::MeshBase.

Definition at line 270 of file distributed_mesh.h.

270 {}

◆ reserve_nodes()

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

Reserves space for a known number of nodes.

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

Implements libMesh::MeshBase.

Definition at line 266 of file distributed_mesh.h.

266 {}

◆ set_count_lower_dim_elems_in_point_locator()

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

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

Definition at line 1605 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

1606 {
1607  _count_lower_dim_elems_in_point_locator = count_lower_dim_elems;
1608 }
bool _count_lower_dim_elems_in_point_locator
Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based po...
Definition: mesh_base.h:1835

◆ set_default_mapping_data()

void libMesh::MeshBase::set_default_mapping_data ( const unsigned char  data)
inlineinherited

Set the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 818 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_data.

Referenced by libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

819  {
820  _default_mapping_data = data;
821  }
unsigned char _default_mapping_data
The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational base...
Definition: mesh_base.h:1815

◆ set_default_mapping_type()

void libMesh::MeshBase::set_default_mapping_type ( const ElemMappingType  type)
inlineinherited

Set the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 800 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_type.

Referenced by libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

801  {
802  _default_mapping_type = type;
803  }
ElemMappingType _default_mapping_type
The default mapping type (typically Lagrange) between master and physical space to assign to newly ad...
Definition: mesh_base.h:1808

◆ set_distributed()

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

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

Reimplemented from libMesh::MeshBase.

Definition at line 168 of file distributed_mesh.h.

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

169  { _is_serial = false;
170  _is_serial_on_proc_0 = false; }
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.

◆ set_elem_dimensions()

void libMesh::MeshBase::set_elem_dimensions ( std::set< unsigned char >  elem_dims)
inherited

Most of the time you should not need to call this, as the element dimensions will be set automatically by a call to cache_elem_data(), therefore only call this if you know what you're doing.

In some specialized situations, for example when adding a single Elem on all procs, it can be faster to skip calling cache_elem_data() and simply specify the element dimensions manually, which is why this setter exists.

Definition at line 333 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, and libMesh::MeshBase::cache_elem_data().

334 {
335 #ifdef DEBUG
336  // In debug mode, we call cache_elem_data() and then make sure
337  // the result actually agrees with what the user specified.
338  parallel_object_only();
339 
340  this->cache_elem_data();
341  libmesh_assert_msg(_elem_dims == elem_dims, \
342  "Specified element dimensions does not match true element dimensions!");
343 #endif
344 
345  _elem_dims = std::move(elem_dims);
346 }
void cache_elem_data()
Definition: mesh_base.C:1662
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895

◆ set_isnt_prepared()

void libMesh::MeshBase::set_isnt_prepared ( )
inlineinherited

Tells this we have done some operation where we should no longer consider ourself prepared.

Definition at line 198 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

199  { _is_prepared = false; }
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820

◆ set_mesh_dimension()

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

Resets the logical dimension of the mesh.

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

Definition at line 269 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

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

270  { _elem_dims.clear(); _elem_dims.insert(d); }
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895

◆ set_n_partitions()

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

Definition at line 1789 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

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

1790  { return _n_parts; }
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802

◆ set_next_unique_id()

void libMesh::DistributedMesh::set_next_unique_id ( unique_id_type  id)
overridevirtualinherited

Sets the next available unique id to be used.

On a ReplicatedMesh, or when adding unpartitioned objects to a DistributedMesh, this must be kept in sync on all processors.

On a DistributedMesh, other unique_id values (larger than this one) may be chosen next, to allow unique_id assignment without communication.

Implements libMesh::MeshBase.

Definition at line 357 of file distributed_mesh.C.

References libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

Referenced by ExodusTest< elem_type >::meshes_equal_enough().

358 {
359  _next_unique_id = id;
361  ((_next_unique_id-1) / (this->n_processors() + 1) + 1) *
362  (this->n_processors() + 1) + this->n_processors();
364  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
365  (this->n_processors() + 1) + this->processor_id();
366 }
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
processor_id_type n_processors() const
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
processor_id_type processor_id() const

◆ set_point_locator_close_to_point_tol()

void libMesh::MeshBase::set_point_locator_close_to_point_tol ( Real  val)
inherited

Set value used by PointLocatorBase::close_to_point_tol().

Defaults to 0.0. If nonzero, calls close_to_point_tol() whenever a new PointLocator is built for use by this Mesh. Since the Mesh controls the creation and destruction of the PointLocator, if there are any parameters we need to customize on it, the Mesh will need to know about them.

Definition at line 1822 of file mesh_base.C.

References libMesh::MeshBase::_point_locator, and libMesh::MeshBase::_point_locator_close_to_point_tol.

1823 {
1825  if (_point_locator)
1826  {
1827  if (val > 0.)
1828  _point_locator->set_close_to_point_tol(val);
1829  else
1830  _point_locator->unset_close_to_point_tol();
1831  }
1832 }
std::unique_ptr< PointLocatorBase > _point_locator
A PointLocator class for this mesh.
Definition: mesh_base.h:1829
Real _point_locator_close_to_point_tol
If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we crea...
Definition: mesh_base.h:2015

◆ set_spatial_dimension()

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

Sets the "spatial dimension" of the Mesh.

See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 502 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

Referenced by MeshSpatialDimensionTest::test2D(), and InfFERadialTest::testRefinement().

503 {
504  // The user can set the _spatial_dimension however they wish,
505  // libMesh will only *increase* the spatial dimension, however,
506  // never decrease it.
507  _spatial_dimension = d;
508 }
unsigned char _spatial_dimension
The "spatial dimension" of the Mesh.
Definition: mesh_base.h:1932

◆ set_subdomain_name_map()

const DofMap& dof_map LIBMESH_COMMA unsigned int std::string& libMesh::MeshBase::set_subdomain_name_map ( )
inlineinherited

Definition at line 1669 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

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

1670  { return _block_id_to_name; }
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888

◆ size_elem_extra_integers()

void libMesh::MeshBase::size_elem_extra_integers ( )
protectedinherited

Size extra-integer arrays of all elements in the mesh.

Definition at line 1843 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_default_values, and libMesh::MeshBase::_elem_integer_names.

Referenced by libMesh::MeshBase::add_elem_data(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integer(), and libMesh::MeshBase::add_elem_integers().

1844 {
1845  const std::size_t new_size = _elem_integer_names.size();
1846  for (auto elem : this->element_ptr_range())
1847  elem->add_extra_integers(new_size, _elem_integer_default_values);
1848 }
std::vector< std::string > _elem_integer_names
The array of names for integer data associated with each element in the mesh.
Definition: mesh_base.h:1938
std::vector< dof_id_type > _elem_integer_default_values
The array of default initialization values for integer data associated with each element in the mesh...
Definition: mesh_base.h:1944

◆ size_node_extra_integers()

void libMesh::MeshBase::size_node_extra_integers ( )
protectedinherited

Size extra-integer arrays of all nodes in the mesh.

Definition at line 1852 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_default_values, and libMesh::MeshBase::_node_integer_names.

Referenced by libMesh::MeshBase::add_node_data(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integer(), and libMesh::MeshBase::add_node_integers().

1853 {
1854  const std::size_t new_size = _node_integer_names.size();
1855  for (auto node : this->node_ptr_range())
1856  node->add_extra_integers(new_size, _node_integer_default_values);
1857 }
std::vector< std::string > _node_integer_names
The array of names for integer data associated with each node in the mesh.
Definition: mesh_base.h:1950
std::vector< dof_id_type > _node_integer_default_values
The array of default initialization values for integer data associated with each node in the mesh...
Definition: mesh_base.h:1956

◆ skip_noncritical_partitioning() [1/2]

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

If true is passed in then the elements on this mesh will no longer be (re)partitioned, and the nodes on this mesh will only be repartitioned if they are found "orphaned" via coarsening or other removal of the last element responsible for their node/element processor id consistency.

Note
It would probably be a bad idea to call this on a DistributedMesh before the first partitioning has happened... because no elements would get assigned to your processor pool.
Skipping partitioning can have adverse effects on your performance when using AMR... i.e. you could get large load imbalances. However you might still want to use this if the communication and computation of the rebalance and repartition is too high for your application.

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

Definition at line 1213 of file mesh_base.h.

References libMesh::MeshBase::_skip_noncritical_partitioning.

Referenced by libMesh::MeshTools::correct_node_proc_ids(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), and MeshInputTest::testCopyNodalSolutionImpl().

1214  { _skip_noncritical_partitioning = skip; }
bool _skip_noncritical_partitioning
If this is true then no partitioning should be done with the possible exception of orphaned nodes...
Definition: mesh_base.h:1856

◆ skip_noncritical_partitioning() [2/2]

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

Definition at line 1216 of file mesh_base.h.

References libMesh::MeshBase::_partitioner, libMesh::MeshBase::_skip_all_partitioning, and libMesh::MeshBase::_skip_noncritical_partitioning.

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

bool _skip_noncritical_partitioning
If this is true then no partitioning should be done with the possible exception of orphaned nodes...
Definition: mesh_base.h:1856
std::unique_ptr< Partitioner > _partitioner
A partitioner to use at each prepare_for_use().
Definition: mesh_base.h:1843
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861

◆ skip_partitioning() [1/2]

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

If true is passed in then nothing on this mesh will be (re)partitioned.

Note
The caveats for skip_noncritical_partitioning() still apply, and removing elements from a mesh with this setting enabled can leave node processor ids in an inconsistent state (not matching any attached element), causing failures in other library code. Do not use this setting along with element deletion or coarsening.

Definition at line 1231 of file mesh_base.h.

References libMesh::MeshBase::_skip_all_partitioning.

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

1231 { _skip_all_partitioning = skip; }
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861

◆ skip_partitioning() [2/2]

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

Definition at line 1233 of file mesh_base.h.

References libMesh::MeshBase::_skip_all_partitioning.

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

1233 { return _skip_all_partitioning; }
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861

◆ spatial_dimension()

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

The spatial dimension is defined as:

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

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

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

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

Definition at line 495 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

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

496 {
497  return cast_int<unsigned int>(_spatial_dimension);
498 }
unsigned char _spatial_dimension
The "spatial dimension" of the Mesh.
Definition: mesh_base.h:1932

◆ stitch_meshes()

std::size_t libMesh::UnstructuredMesh::stitch_meshes ( const MeshBase other_mesh,
boundary_id_type  this_mesh_boundary,
boundary_id_type  other_mesh_boundary,
Real  tol = TOLERANCE,
bool  clear_stitched_boundary_ids = false,
bool  verbose = true,
bool  use_binary_search = true,
bool  enforce_all_nodes_match_on_boundaries = false,
bool  merge_boundary_nodes_all_or_nothing = false,
bool  remap_subdomain_ids = false 
)
inherited

Stitch other_mesh to this mesh so that this mesh is the union of the two meshes.

this_mesh_boundary and other_mesh_boundary are used to specify a dim-1 dimensional surface on which we seek to merge any "overlapping" nodes, where we use the parameter tol as a relative tolerance (relative to the smallest edge length on the surfaces being stitched) to determine whether or not nodes are overlapping. If clear_stitched_boundary_ids==true, this function clears boundary_info IDs in this mesh associated this_mesh_boundary and other_mesh_boundary. If use_binary_search is true, we use an optimized "sort then binary search" algorithm for finding matching nodes. Otherwise we use a N^2 algorithm (which can be more reliable at dealing with slightly misaligned meshes). If enforce_all_nodes_match_on_boundaries is true, we throw an error if the number of nodes on the specified boundaries don't match the number of nodes that were merged. This is a helpful error check in some cases. If this is true, it overrides the value of merge_boundary_nodes_all_or_nothing. If skip_find_neighbors is true, a faster stitching method is used, where the lists of neighbors for each elements are copied as well and patched, without calling the time-consuming find_neighbors() function. This option is now hard-coded to true. If merge_boundary_nodes_all_or_nothing is true, instead of throwing an error like enforce_all_nodes_match_on_boundaries, the meshes are combined anyway but coincident nodes are not merged into single nodes. This is useful in cases where you are not sure if the boundaries are fully conforming beforehand and you want to handle the non-conforming cases differently.

Note that the element IDs for elements in the stitched mesh corresponding to "this" mesh will be unchanged. The IDs for elements corresponding to other_mesh will be incremented by this->max_elem_id().

There is no simple a priori relationship between node IDs in "this" mesh and other_mesh and node IDs in the stitched mesh because the number of nodes (and hence the node IDs) in the stitched mesh depend on how many nodes are stitched.

If remap_subdomain_ids is true then we assume that some subdomain ids might have been autogenerated, so we remap them as necessary, treating subdomain names as the important thing for consistency; if we have missing names and cannot infer a consistent resolution to an id conflict then we exit with an error. If remap_subdomain_ids is false then we revert to the older libMesh behavior: leave all subdomain ids alone and woe unto you if you weren't keeping track of them.

Returns
the count of how many nodes were merged between the two meshes. This can be zero in the case of no matching nodes or if merge_boundary_nodes_all_or_nothing was active and relevant.

Definition at line 1750 of file unstructured_mesh.C.

References libMesh::UnstructuredMesh::stitching_helper().

1760 {
1761  LOG_SCOPE("stitch_meshes()", "UnstructuredMesh");
1762  return stitching_helper(&other_mesh,
1763  this_mesh_boundary_id,
1764  other_mesh_boundary_id,
1765  tol,
1766  clear_stitched_boundary_ids,
1767  verbose,
1768  use_binary_search,
1769  enforce_all_nodes_match_on_boundaries,
1770  true,
1771  merge_boundary_nodes_all_or_nothing,
1772  remap_subdomain_ids);
1773 }
std::size_t stitching_helper(const MeshBase *other_mesh, boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol, bool clear_stitched_boundary_ids, bool verbose, bool use_binary_search, bool enforce_all_nodes_match_on_boundaries, bool skip_find_neighbors, bool merge_boundary_nodes_all_or_nothing, bool remap_subdomain_ids)
Helper function for stitch_meshes and stitch_surfaces that does the mesh stitching.

◆ stitch_surfaces()

std::size_t libMesh::UnstructuredMesh::stitch_surfaces ( boundary_id_type  boundary_id_1,
boundary_id_type  boundary_id_2,
Real  tol = TOLERANCE,
bool  clear_stitched_boundary_ids = false,
bool  verbose = true,
bool  use_binary_search = true,
bool  enforce_all_nodes_match_on_boundaries = false,
bool  merge_boundary_nodes_all_or_nothing = false 
)
inherited

Similar to stitch_meshes, except that we stitch two adjacent surfaces within this mesh.

Definition at line 1777 of file unstructured_mesh.C.

References libMesh::UnstructuredMesh::stitching_helper().

1786 {
1787  return stitching_helper(nullptr,
1788  boundary_id_1,
1789  boundary_id_2,
1790  tol,
1791  clear_stitched_boundary_ids,
1792  verbose,
1793  use_binary_search,
1794  enforce_all_nodes_match_on_boundaries,
1795  true,
1796  merge_boundary_nodes_all_or_nothing,
1797  false);
1798 }
std::size_t stitching_helper(const MeshBase *other_mesh, boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol, bool clear_stitched_boundary_ids, bool verbose, bool use_binary_search, bool enforce_all_nodes_match_on_boundaries, bool skip_find_neighbors, bool merge_boundary_nodes_all_or_nothing, bool remap_subdomain_ids)
Helper function for stitch_meshes and stitch_surfaces that does the mesh stitching.

◆ sub_point_locator()

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

Definition at line 1565 of file mesh_base.C.

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

Referenced by WriteElemsetData::checkElemsetCodes(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshFunction::init(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::DefaultCoupling::mesh_reinit(), libMesh::PointNeighborCoupling::mesh_reinit(), ExodusTest< elem_type >::meshes_equal_enough(), libMesh::MeshRefinement::test_level_one(), PointLocatorTest::testLocator(), MeshInputTest::testMasterCenters(), PointLocatorTest::testPlanar(), SystemsTest::testProjectCube(), SystemsTest::testProjectLine(), and SystemsTest::testProjectSquare().

1566 {
1567  // If there's no master point locator, then we need one.
1568  if (_point_locator.get() == nullptr)
1569  {
1570  // PointLocator construction may not be safe within threads
1572 
1573  // And it may require parallel communication
1574  parallel_object_only();
1575 
1576 #ifdef LIBMESH_ENABLE_NANOFLANN_POINTLOCATOR
1578 #else
1580 #endif
1581 
1583  _point_locator->set_close_to_point_tol(_point_locator_close_to_point_tol);
1584  }
1585 
1586  // Otherwise there was a master point locator, and we can grab a
1587  // sub-locator easily.
1588  return
1589 #ifdef LIBMESH_ENABLE_NANOFLANN_POINTLOCATOR
1591 #else
1593 #endif
1594 }
bool in_threads
A boolean which is true iff we are in a Threads:: function It may be useful to assert(!Threadsin_thre...
Definition: threads.C:32
libmesh_assert(ctx)
std::unique_ptr< PointLocatorBase > _point_locator
A PointLocator class for this mesh.
Definition: mesh_base.h:1829
Real _point_locator_close_to_point_tol
If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we crea...
Definition: mesh_base.h:2015
static std::unique_ptr< PointLocatorBase > build(PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)
Builds an PointLocator for the mesh mesh.

◆ subclass_locally_equals()

bool libMesh::DistributedMesh::subclass_locally_equals ( const MeshBase other_mesh) const
overridevirtualinherited

Shim to allow operator == (&) to behave like a virtual function without having to be one.

Implements libMesh::MeshBase.

Definition at line 97 of file distributed_mesh.C.

References libMesh::DistributedMesh::_deleted_coarse_elements, libMesh::DistributedMesh::_extra_ghost_elems, libMesh::DistributedMesh::_is_serial, libMesh::DistributedMesh::_is_serial_on_proc_0, libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_max_node_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_n_nodes, libMesh::libmesh_assert(), and libMesh::DistributedMesh::query_elem_ptr().

98 {
99  const DistributedMesh * dist_mesh_ptr =
100  dynamic_cast<const DistributedMesh *>(&other_mesh_base);
101  if (!dist_mesh_ptr)
102  return false;
103  const DistributedMesh & other_mesh = *dist_mesh_ptr;
104 
105  if (_is_serial != other_mesh._is_serial ||
106  _is_serial_on_proc_0 != other_mesh._is_serial_on_proc_0 ||
107  _deleted_coarse_elements != other_mesh._deleted_coarse_elements ||
108  _n_nodes != other_mesh._n_nodes ||
109  _n_elem != other_mesh._n_elem ||
110  _max_node_id != other_mesh._max_node_id ||
111  _max_elem_id != other_mesh._max_elem_id ||
112  // We expect these things to change in a prepare_for_use();
113  // they're conceptually "mutable"...
114 /*
115  _next_free_local_node_id != other_mesh._next_free_local_node_id ||
116  _next_free_local_elem_id != other_mesh._next_free_local_elem_id ||
117  _next_free_unpartitioned_node_id != other_mesh._next_free_unpartitioned_node_id ||
118  _next_free_unpartitioned_elem_id != other_mesh._next_free_unpartitioned_elem_id ||
119 #ifdef LIBMESH_ENABLE_UNIQUE_ID
120  _next_unpartitioned_unique_id != other_mesh._next_unpartitioned_unique_id ||
121 #endif
122 */
123  !this->nodes_and_elements_equal(other_mesh))
124  return false;
125 
126  if (_extra_ghost_elems.size() !=
127  other_mesh._extra_ghost_elems.size())
128  return false;
129  for (auto & elem : _extra_ghost_elems)
130  {
131  libmesh_assert(this->query_elem_ptr(elem->id()) == elem);
132  const Elem * other_elem = other_mesh.query_elem_ptr(elem->id());
133  if (!other_elem ||
134  !other_mesh._extra_ghost_elems.count(const_cast<Elem *>(other_elem)))
135  return false;
136  }
137 
138  return true;
139 }
bool _is_serial_on_proc_0
A boolean remembering whether we&#39;re serialized to proc 0 or not.
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
bool _is_serial
A boolean remembering whether we&#39;re serialized or not.
std::set< Elem * > _extra_ghost_elems
These are extra ghost elements that we want to make sure not to delete when we call delete_remote_ele...
libmesh_assert(ctx)
DistributedMesh(const Parallel::Communicator &comm_in, unsigned char dim=1)
Constructor.
bool _deleted_coarse_elements
A boolean remembering whether we&#39;ve recently deleted top-level elements or not.
virtual const Elem * query_elem_ptr(const dof_id_type i) const override final

◆ subdomain_ids()

void libMesh::MeshBase::subdomain_ids ( std::set< subdomain_id_type > &  ids,
const bool  global = true 
) const
inherited

Constructs a list of all subdomain identifiers in the local mesh if global == false, and in the global mesh if global == true (default).

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.

Unpartitioned elements are included in the set in the case that global == true. If global == false, the unpartitioned elements are not included because unpartitioned elements do not have a sense of locality.

Definition at line 899 of file mesh_base.C.

References libMesh::ParallelObject::comm(), and TIMPI::Communicator::set_union().

Referenced by libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::MeshBase::n_local_subdomains(), libMesh::MeshBase::n_subdomains(), libMesh::TecplotIO::TecplotIO(), MeshSubdomainIDTest::testMultiple(), and MeshSubdomainIDTest::testUnpartitioned().

900 {
901  // This requires an inspection on every processor
902  if (global)
903  parallel_object_only();
904 
905  ids.clear();
906 
907  for (const auto & elem : this->active_local_element_ptr_range())
908  ids.insert(elem->subdomain_id());
909 
910  if (global)
911  {
912  // Only include the unpartitioned elements if the user requests the global IDs.
913  // In the case of the local subdomain IDs, it doesn't make sense to include the
914  // unpartitioned elements because said elements do not have a sense of locality.
915  for (const auto & elem : this->active_unpartitioned_element_ptr_range())
916  ids.insert(elem->subdomain_id());
917 
918  // Some subdomains may only live on other processors
919  this->comm().set_union(ids);
920  }
921 }
const Parallel::Communicator & comm() const
void set_union(T &data, const unsigned int root_id) const

◆ subdomain_name() [1/2]

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

Definition at line 1619 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::AbaqusIO::assign_subdomain_ids(), DMlibMeshSetSystem_libMesh(), libMesh::UNVIO::groups_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testAmbiguousRemappingStitch(), MeshStitchTest::testRemappingStitch(), libMesh::TecplotIO::write_binary(), and libMesh::ExodusII_IO_Helper::write_elements().

1620 {
1621  return _block_id_to_name[id];
1622 }
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888

◆ subdomain_name() [2/2]

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

Definition at line 1624 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

1625 {
1626  // An empty string to return when no matching subdomain name is found
1627  static const std::string empty;
1628 
1629  std::map<subdomain_id_type, std::string>::const_iterator iter = _block_id_to_name.find(id);
1630  if (iter == _block_id_to_name.end())
1631  return empty;
1632  else
1633  return iter->second;
1634 }
std::map< subdomain_id_type, std::string > _block_id_to_name
This structure maintains the mapping of named blocks for file formats that support named blocks...
Definition: mesh_base.h:1888

◆ update_parallel_id_counts()

void libMesh::DistributedMesh::update_parallel_id_counts ( )
overridevirtualinherited

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

Implements libMesh::MeshBase.

Definition at line 255 of file distributed_mesh.C.

References libMesh::DistributedMesh::_max_elem_id, libMesh::DistributedMesh::_max_node_id, libMesh::DistributedMesh::_n_elem, libMesh::DistributedMesh::_n_nodes, libMesh::DistributedMesh::_next_free_local_elem_id, libMesh::DistributedMesh::_next_free_local_node_id, libMesh::DistributedMesh::_next_free_unpartitioned_elem_id, libMesh::DistributedMesh::_next_free_unpartitioned_node_id, libMesh::MeshBase::_next_unique_id, libMesh::DistributedMesh::_next_unpartitioned_unique_id, libMesh::ParallelObject::n_processors(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), and libMesh::ParallelObject::processor_id().

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

256 {
257  // This function must be run on all processors at once
258  parallel_object_only();
259 
260  _n_elem = this->parallel_n_elem();
261  _n_nodes = this->parallel_n_nodes();
264 
267  ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
268  (this->n_processors() + 1) + this->n_processors();
271  ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
272  (this->n_processors() + 1) + this->processor_id();
273 
276  ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
277  (this->n_processors() + 1) + this->n_processors();
280  ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
281  (this->n_processors() + 1) + this->processor_id();
282 
283 #ifdef LIBMESH_ENABLE_UNIQUE_ID
286  ((_next_unique_id-1) / (this->n_processors() + 1) + 1) *
287  (this->n_processors() + 1) + this->n_processors();
289  ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
290  (this->n_processors() + 1) + this->processor_id();
291 #endif
292 }
virtual dof_id_type parallel_n_nodes() const override
dof_id_type _n_nodes
Cached data from the last renumber_nodes_and_elements call.
dof_id_type _next_free_local_node_id
Guaranteed globally unused IDs for use when adding new nodes or elements.
virtual unique_id_type parallel_max_unique_id() const override
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
processor_id_type n_processors() const
virtual dof_id_type parallel_n_elem() const override
dof_id_type parallel_max_node_id() const
dof_id_type _next_free_unpartitioned_node_id
dof_id_type _next_free_unpartitioned_elem_id
unique_id_type _next_unpartitioned_unique_id
The next available unique id for assigning ids to unpartitioned DOF objects.
processor_id_type processor_id() const
dof_id_type _next_free_local_elem_id
dof_id_type parallel_max_elem_id() const

◆ update_post_partitioning()

void libMesh::DistributedMesh::update_post_partitioning ( )
overridevirtualinherited

Recalculate cached data after elements and nodes have been repartitioned.

Reimplemented from libMesh::MeshBase.

Definition at line 1072 of file distributed_mesh.C.

References libMesh::DistributedMesh::update_parallel_id_counts().

1073 {
1074  // this->recalculate_n_partitions();
1075 
1076  // Partitioning changes our numbers of unpartitioned objects
1077  this->update_parallel_id_counts();
1078 }
virtual void update_parallel_id_counts() override
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors...

◆ write() [1/2]

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

Write the file specified by name.

Attempts to figure out the proper method by the file extension.

Implements libMesh::MeshBase.

Definition at line 1253 of file unstructured_mesh.C.

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

Referenced by main().

1254 {
1255  LOG_SCOPE("write()", "Mesh");
1256 
1257  NameBasedIO(*this).write(name);
1258 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
This class supports simple reads and writes in any libMesh-supported format, by dispatching to one of...
Definition: namebased_io.h:44
virtual void write(const std::string &mesh_file) override
This method implements writing a mesh to a specified file.
Definition: namebased_io.C:310

◆ write() [2/2]

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

Write to the file specified by name.

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

Definition at line 1262 of file unstructured_mesh.C.

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

1265 {
1266  LOG_SCOPE("write()", "Mesh");
1267 
1268  NameBasedIO(*this).write_nodal_data(name, v, vn);
1269 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
This class supports simple reads and writes in any libMesh-supported format, by dispatching to one of...
Definition: namebased_io.h:44
virtual void write_nodal_data(const std::string &, const std::vector< Number > &, const std::vector< std::string > &) override
This method implements writing a mesh with nodal data to a specified file where the nodal data and va...
Definition: namebased_io.C:467

Member Data Documentation

◆ _all_elemset_ids

MeshBase::elemset_type libMesh::MeshBase::_all_elemset_ids
protectedinherited

◆ _allow_remote_element_removal

bool libMesh::MeshBase::_allow_remote_element_removal
protectedinherited

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

This is true by default.

Definition at line 1881 of file mesh_base.h.

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

◆ _block_id_to_name

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

This structure maintains the mapping of named blocks for file formats that support named blocks.

Currently this is only implemented for ExodusII

Definition at line 1888 of file mesh_base.h.

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

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited

◆ _constraint_rows

constraint_rows_type libMesh::MeshBase::_constraint_rows
protectedinherited

◆ _count_lower_dim_elems_in_point_locator

bool libMesh::MeshBase::_count_lower_dim_elems_in_point_locator
protectedinherited

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

Definition at line 1835 of file mesh_base.h.

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

◆ _default_ghosting

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

The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior.

We use a base class pointer here to avoid dragging in more header dependencies.

Definition at line 1982 of file mesh_base.h.

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

◆ _default_mapping_data

unsigned char libMesh::MeshBase::_default_mapping_data
protectedinherited

The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational bases) to assign to newly added elements.

Definition at line 1815 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_default_mapping_data().

◆ _default_mapping_type

ElemMappingType libMesh::MeshBase::_default_mapping_type
protectedinherited

The default mapping type (typically Lagrange) between master and physical space to assign to newly added elements.

Definition at line 1808 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_mapping_type(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_default_mapping_type().

◆ _deleted_coarse_elements

bool libMesh::DistributedMesh::_deleted_coarse_elements
inherited

A boolean remembering whether we've recently deleted top-level elements or not.

If so, we'll need to be extra careful when deleting "unused" nodes they used to have, because those nodes might still be used by ghost elements.

Definition at line 444 of file distributed_mesh.h.

Referenced by libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::renumber_nodes_and_elements(), and libMesh::DistributedMesh::subclass_locally_equals().

◆ _elem_dims

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

◆ _elem_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_elem_integer_default_values
protectedinherited

◆ _elem_integer_names

std::vector<std::string> libMesh::MeshBase::_elem_integer_names
protectedinherited

◆ _elements

dofobject_container<Elem> libMesh::DistributedMesh::_elements
inherited

◆ _elemset_codes

std::map<dof_id_type, const MeshBase::elemset_type *> libMesh::MeshBase::_elemset_codes
protectedinherited

Map from "element set code" to list of set ids to which that element belongs (and vice-versa).

Remarks: 1.) The elemset code is a dof_id_type because (if used) it is stored as an extra_integer (named "elemset_code") on all elements, and extra_integers are of type dof_id_type. Elements which do not belong to any set should be assigned an elemset code of DofObject::invalid_id. 2.) Element sets can be thought of as a generalization of the concept of a subdomain. Subdomains have the following restrictions: a.) A given element can only belong to a single subdomain b.) When using Exodus file input/output, subdomains are (unfortunately) tied to the concept of exodus element blocks, which consist of a single geometric element type, somewhat limiting their generality. 3.) The user is responsible for filling in the values of this map in a consistent manner, unless the elemsets are read in from an Exodus file, in which case the elemset codes will be set up automatically. The codes can basically be chosen arbitrarily, with the one requirement that elements which belong to no sets should have a set code of DofObject::invalid_id. 4.) We also keep a list of all the elemset ids which have been added in order to support O(1) performance behavior in n_elemsets() calls.

Definition at line 1924 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::change_elemset_code(), libMesh::MeshBase::change_elemset_id(), libMesh::MeshBase::clear(), libMesh::MeshBase::get_elemset_codes(), libMesh::MeshBase::get_elemsets(), libMesh::MeshBase::get_info(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::MeshBase(), and libMesh::MeshBase::operator=().

◆ _elemset_codes_inverse_map

std::map<MeshBase::elemset_type, dof_id_type> libMesh::MeshBase::_elemset_codes_inverse_map
protectedinherited

◆ _extra_ghost_elems

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

◆ _ghosting_functors

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

◆ _is_prepared

bool libMesh::MeshBase::_is_prepared
protectedinherited

◆ _is_serial

bool libMesh::DistributedMesh::_is_serial
inherited

◆ _is_serial_on_proc_0

bool libMesh::DistributedMesh::_is_serial_on_proc_0
inherited

◆ _max_elem_id

dof_id_type libMesh::DistributedMesh::_max_elem_id
inherited

◆ _max_node_id

dof_id_type libMesh::DistributedMesh::_max_node_id
inherited

◆ _mesh_subdomains

std::set<subdomain_id_type> libMesh::MeshBase::_mesh_subdomains
protectedinherited

We cache the subdomain ids of the elements present in the mesh.

Definition at line 1900 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::get_mesh_subdomains(), and libMesh::MeshBase::locally_equals().

◆ _n_elem

dof_id_type libMesh::DistributedMesh::_n_elem
inherited

◆ _n_nodes

dof_id_type libMesh::DistributedMesh::_n_nodes
inherited

◆ _n_parts

unsigned int libMesh::MeshBase::_n_parts
protectedinherited

The number of partitions the mesh has.

This is set by the partitioners, and may not be changed directly by the user.

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

Definition at line 1802 of file mesh_base.h.

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

◆ _next_free_local_elem_id

dof_id_type libMesh::DistributedMesh::_next_free_local_elem_id
inherited

◆ _next_free_local_node_id

dof_id_type libMesh::DistributedMesh::_next_free_local_node_id
inherited

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

Definition at line 455 of file distributed_mesh.h.

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

◆ _next_free_unpartitioned_elem_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_elem_id
inherited

◆ _next_free_unpartitioned_node_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_node_id
inherited

◆ _next_unique_id

unique_id_type libMesh::MeshBase::_next_unique_id
protectedinherited

◆ _next_unpartitioned_unique_id

unique_id_type libMesh::DistributedMesh::_next_unpartitioned_unique_id
inherited

◆ _node_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_node_integer_default_values
protectedinherited

◆ _node_integer_names

std::vector<std::string> libMesh::MeshBase::_node_integer_names
protectedinherited

◆ _nodes

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS (multi_evaluable_, std::vector<const DofMap *> dof_maps, dof_maps) protected dofobject_container<Node> libMesh::DistributedMesh::_nodes
inherited

◆ _partitioner

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

◆ _point_locator

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

A PointLocator class for this mesh.

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

Definition at line 1829 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear_point_locator(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_point_locator_close_to_point_tol(), and libMesh::MeshBase::sub_point_locator().

◆ _point_locator_close_to_point_tol

Real libMesh::MeshBase::_point_locator_close_to_point_tol
protectedinherited

◆ _shared_functors

std::map<GhostingFunctor *, std::shared_ptr<GhostingFunctor> > libMesh::MeshBase::_shared_functors
protectedinherited

Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.

Definition at line 1997 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_ghosting_functor(), libMesh::MeshBase::post_dofobject_moves(), and libMesh::MeshBase::remove_ghosting_functor().

◆ _skip_all_partitioning

bool libMesh::MeshBase::_skip_all_partitioning
protectedinherited

◆ _skip_find_neighbors

bool libMesh::MeshBase::_skip_find_neighbors
protectedinherited

If this is true then we will skip find_neighbors in prepare_for_use.

Definition at line 1873 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::prepare_for_use().

◆ _skip_noncritical_partitioning

bool libMesh::MeshBase::_skip_noncritical_partitioning
protectedinherited

If this is true then no partitioning should be done with the possible exception of orphaned nodes.

Definition at line 1856 of file mesh_base.h.

Referenced by libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::skip_noncritical_partitioning().

◆ _skip_renumber_nodes_and_elements

bool libMesh::MeshBase::_skip_renumber_nodes_and_elements
protectedinherited

◆ _spatial_dimension

unsigned char libMesh::MeshBase::_spatial_dimension
protectedinherited

◆ boundary_info

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

This class holds the boundary information.

It can store nodes, edges, and faces with a corresponding id that facilitates setting boundary conditions.

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

Definition at line 1760 of file mesh_base.h.

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

◆ level [1/2]

unsigned int libMesh::DistributedMesh::level
inherited

Definition at line 355 of file distributed_mesh.h.

◆ level [2/2]

processor_id_type pid unsigned int libMesh::DistributedMesh::level
inherited

Definition at line 382 of file distributed_mesh.h.

◆ pid [1/2]

processor_id_type libMesh::DistributedMesh::pid
inherited

◆ pid [2/2]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type libMesh::DistributedMesh::pid
inherited

Definition at line 404 of file distributed_mesh.h.

◆ rflag

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char libMesh::DistributedMesh::rflag
inherited

Definition at line 394 of file distributed_mesh.h.

◆ ss [1/2]

unsigned int level ElemType type std::set<subdomain_id_type> libMesh::DistributedMesh::ss
inherited

◆ ss [2/2]

processor_id_type pid unsigned int level std::set<subdomain_id_type> libMesh::DistributedMesh::ss
inherited

Definition at line 384 of file distributed_mesh.h.

◆ type

unsigned int level ElemType libMesh::DistributedMesh::type
inherited

Definition at line 357 of file distributed_mesh.h.

◆ var_num [1/2]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::DistributedMesh::var_num = libMesh::invalid_uint
inherited

Definition at line 390 of file distributed_mesh.h.

◆ var_num [2/2]

processor_id_type pid unsigned int level std::set<subdomain_id_type> ss const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::DistributedMesh::var_num = libMesh::invalid_uint
inherited

Definition at line 407 of file distributed_mesh.h.


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