libMesh
Classes | Public Types | Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Friends | List of all members
libMesh::MeshBase Class Referenceabstract

This is the MeshBase class. More...

#include <mesh_base.h>

Inheritance diagram for libMesh::MeshBase:
[legend]

Classes

struct  const_element_iterator
 The definition of the const_element_iterator struct. More...
 
struct  const_node_iterator
 The definition of the const_node_iterator struct. More...
 
struct  element_iterator
 The definition of the element_iterator struct. More...
 
struct  node_iterator
 The definition of the node_iterator struct. More...
 

Public Types

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

 MeshBase (const Parallel::Communicator &comm_in, unsigned char dim=1)
 Constructor. More...
 
 MeshBase (const MeshBase &other_mesh)
 Copy-constructor. More...
 
 MeshBase (MeshBase &&)=delete
 Move-constructor - deleted because after a theoretical move-construction and then destruction of the moved-from object, the moved BoundaryInfo would hold an invalid reference to the moved-from mesh. More...
 
MeshBaseoperator= (const MeshBase &)=delete
 Copy and move assignment are not allowed because MeshBase subclasses manually manage memory (Elems and Nodes) and therefore the default versions of these operators would leak memory. More...
 
MeshBaseoperator= (MeshBase &&other_mesh)
 
virtual MeshBaseassign (MeshBase &&other_mesh)=0
 Shim to allow operator = (&&) to behave like a virtual function without having to be one. 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< MeshBaseclone () const =0
 Virtual "copy constructor". More...
 
virtual ~MeshBase ()
 Destructor. 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...
 
virtual void clear ()
 Deletes all the element and node data that is currently stored. More...
 
virtual void clear_elems ()=0
 Deletes all the element data that is currently stored. 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...
 
virtual bool is_serial () const
 
virtual bool is_serial_on_zero () const
 
virtual void set_distributed ()
 Asserts that not all elements and nodes of the mesh necessarily exist on the current processor. More...
 
virtual bool is_replicated () const
 
virtual void allgather ()
 Gathers all elements and nodes of the mesh onto every processor. More...
 
virtual void gather_to_zero ()
 Gathers all elements and nodes of the mesh onto processor zero. More...
 
virtual void delete_remote_elements ()
 When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local element, and deletes all nodes which are not part of a local or ghost element. 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...
 
virtual dof_id_type n_nodes () const =0
 
virtual dof_id_type parallel_n_nodes () const =0
 
dof_id_type n_nodes_on_proc (const processor_id_type proc) const
 
dof_id_type n_local_nodes () const
 
dof_id_type n_unpartitioned_nodes () const
 
virtual dof_id_type max_node_id () const =0
 
unique_id_type next_unique_id ()
 
virtual void set_next_unique_id (unique_id_type id)=0
 Sets the next available unique id to be used. More...
 
virtual void reserve_nodes (const dof_id_type nn)=0
 Reserves space for a known number of nodes. More...
 
virtual dof_id_type n_elem () const =0
 
virtual dof_id_type parallel_n_elem () const =0
 
virtual dof_id_type max_elem_id () const =0
 
virtual unique_id_type parallel_max_unique_id () const =0
 
virtual void reserve_elem (const dof_id_type ne)=0
 Reserves space for a known number of elements. More...
 
virtual void update_parallel_id_counts ()=0
 Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors. More...
 
virtual dof_id_type n_active_elem () const =0
 
dof_id_type n_elem_on_proc (const processor_id_type proc) const
 
dof_id_type n_local_elem () const
 
dof_id_type n_unpartitioned_elem () const
 
dof_id_type n_active_elem_on_proc (const processor_id_type proc) const
 
dof_id_type n_active_local_elem () const
 
dof_id_type n_sub_elem () const
 
dof_id_type n_active_sub_elem () const
 Same as n_sub_elem(), but only counts active elements. More...
 
virtual const Pointpoint (const dof_id_type i) const =0
 
virtual const Nodenode_ref (const dof_id_type i) const
 
virtual Nodenode_ref (const dof_id_type i)
 
virtual const Nodenode_ptr (const dof_id_type i) const =0
 
virtual Nodenode_ptr (const dof_id_type i)=0
 
virtual const Nodequery_node_ptr (const dof_id_type i) const =0
 
virtual Nodequery_node_ptr (const dof_id_type i)=0
 
virtual const Elemelem_ref (const dof_id_type i) const
 
virtual Elemelem_ref (const dof_id_type i)
 
virtual const Elemelem_ptr (const dof_id_type i) const =0
 
virtual Elemelem_ptr (const dof_id_type i)=0
 
virtual const Elemquery_elem_ptr (const dof_id_type i) const =0
 
virtual Elemquery_elem_ptr (const dof_id_type i)=0
 
virtual Nodeadd_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
 Add a new Node at Point p to the end of the vertex array, with processor_id procid. More...
 
virtual Nodeadd_node (Node *n)=0
 Add Node n to the end of the vertex array. More...
 
virtual Nodeadd_node (std::unique_ptr< Node > n)=0
 Version of add_node() taking a std::unique_ptr by value. More...
 
virtual Nodeinsert_node (Node *n)=0
 This method is deprecated. More...
 
virtual Nodeinsert_node (std::unique_ptr< Node > n)=0
 This method is deprecated. More...
 
virtual void delete_node (Node *n)=0
 Removes the Node n from the mesh. More...
 
virtual void own_node (Node &)
 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 renumber_node (dof_id_type old_id, dof_id_type new_id)=0
 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)=0
 Add elem e to the end of the element array. More...
 
virtual Elemadd_elem (std::unique_ptr< Elem > e)=0
 Version of add_elem() taking a std::unique_ptr by value. More...
 
virtual Eleminsert_elem (Elem *e)=0
 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)=0
 Version of insert_elem() taking a std::unique_ptr by value. More...
 
virtual void delete_elem (Elem *e)=0
 Removes element e from the mesh. More...
 
virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id)=0
 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...
 
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...
 
virtual void find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true)=0
 Locate element face (edge in 2D) neighbors. More...
 
void remove_orphaned_nodes ()
 Removes any orphaned nodes, nodes not connected to any elements. More...
 
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 contiguous blocks on the processors. More...
 
virtual void fix_broken_node_and_element_numbering ()=0
 There is no reason for a user to ever call this function. More...
 
virtual bool contract ()=0
 Delete subactive (i.e. 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 ()
 
virtual void redistribute ()
 Redistribute elements between processors. More...
 
virtual void update_post_partitioning ()
 Recalculate any cached data after elements and nodes have been repartitioned. More...
 
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...
 
virtual void read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false)=0
 Interfaces for reading/writing a mesh to/from a file. More...
 
virtual void write (const std::string &name)=0
 
virtual void all_first_order ()=0
 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)=0
 Converts a set of this Mesh's elements defined by range from FIRST order to SECOND order. 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_range (const SimpleRange< element_iterator > &range)=0
 Converts a set of elements in this (conforming, non-refined) mesh into "complete" order elements, i.e. 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...
 
virtual void libmesh_assert_valid_parallel_ids () const
 Verify id and processor_id consistency of our elements and nodes containers. 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_
 
unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level std::set< subdomain_id_type > virtual ss SimpleRange< element_iteratoractive_subdomain_elements_ptr_range (subdomain_id_type sid)=0
 
virtual SimpleRange< const_element_iteratoractive_subdomain_elements_ptr_range (subdomain_id_type sid) const =0
 
virtual SimpleRange< element_iteratoractive_local_subdomain_elements_ptr_range (subdomain_id_type sid)=0
 
virtual SimpleRange< const_element_iteratoractive_local_subdomain_elements_ptr_range (subdomain_id_type sid) const =0
 
virtual SimpleRange< element_iteratoractive_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss)=0
 
virtual SimpleRange< const_element_iteratoractive_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) const =0
 
 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...
 
constraint_rows_typeget_constraint_rows ()
 
const constraint_rows_typeget_constraint_rows () const
 
template<typename T >
void copy_constraint_rows (const SparseMatrix< T > &constraint_operator)
 Copy the constraints from the given matrix to this mesh. More...
 
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

const DofMap &dof_map LIBMESH_COMMA unsigned int var_num
 

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_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_filter_iter
 
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, const Elem *const, const Elem *const &, const Elem *const * > const_elem_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, 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...
 
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. 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
 

Friends

class Partitioner
 The partitioner class is a friend so that it can set the number of partitions. More...
 
class MeshInput< MeshBase >
 The MeshInput classes are friends so that they can set the number of partitions. More...
 
class BoundaryInfo
 Make the BoundaryInfo class a friend so that it can create and interact with BoundaryMesh. More...
 
class MeshCommunication
 Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names. More...
 
std::ostream & operator<< (std::ostream &os, const MeshBase &m)
 Equivalent to calling print_info() above, but now you can write: Mesh mesh; libMesh::out << mesh << std::endl;. More...
 

Detailed Description

This is the MeshBase class.

This class provides all the data necessary to describe a geometric entity. It allows for the description of a dim dimensional object that lives in LIBMESH_DIM-dimensional space.

A mesh is made of nodes and elements, and this class provides data structures to store and access both. A mesh may be partitioned into a number of subdomains, and this class provides that functionality. Furthermore, this class provides functions for reading and writing a mesh to disk in various formats.
Author
Benjamin S. Kirk
Date
2002 Base class for Mesh.

Definition at line 74 of file mesh_base.h.

Member Typedef Documentation

◆ const_elem_filter_iter [1/2]

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
protected

Definition at line 2072 of file mesh_base.h.

◆ const_node_filter_iter [1/2]

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
protected

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

Definition at line 1674 of file mesh_base.h.

◆ constraint_rows_type

Definition at line 1675 of file mesh_base.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
protected

Definition at line 2067 of file mesh_base.h.

◆ elemset_type

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
protected

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

◆ MeshBase() [1/3]

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

Constructor.

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

Definition at line 58 of file mesh_base.C.

References _default_ghosting, _elem_dims, _ghosting_functors, libMesh::initialized(), and libMesh::libmesh_assert().

59  :
60  ParallelObject (comm_in),
61  boundary_info (new BoundaryInfo(*this)), // BoundaryInfo has protected ctor, can't use std::make_unique
62  _n_parts (1),
65  _is_prepared (false),
66  _point_locator (),
68  _partitioner (),
69 #ifdef LIBMESH_ENABLE_UNIQUE_ID
71 #endif
73  _skip_all_partitioning(libMesh::on_command_line("--skip-partitioning")),
75  _skip_find_neighbors(false),
78  _default_ghosting(std::make_unique<GhostPointNeighbors>(*this)),
80 {
81  _elem_dims.insert(d);
83  libmesh_assert_less_equal (LIBMESH_DIM, 3);
84  libmesh_assert_greater_equal (LIBMESH_DIM, d);
86 }
ParallelObject(const Parallel::Communicator &comm_in)
Constructor.
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868
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
friend class BoundaryInfo
Make the BoundaryInfo class a friend so that it can create and interact with BoundaryMesh.
Definition: mesh_base.h:2033
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
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
static const unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
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
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 initialized()
Checks that library initialization has been done.
Definition: libmesh.C:266
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861
bool on_command_line(std::string arg)
Definition: libmesh.C:924
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
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

◆ MeshBase() [2/3]

libMesh::MeshBase::MeshBase ( const MeshBase other_mesh)

Copy-constructor.

Definition at line 90 of file mesh_base.C.

References _default_ghosting, _elemset_codes, _elemset_codes_inverse_map, _ghosting_functors, _partitioner, add_ghosting_functor(), and libMesh::GhostingFunctor::clone().

90  :
91  ParallelObject (other_mesh),
92  boundary_info (new BoundaryInfo(*this)), // BoundaryInfo has protected ctor, can't use std::make_unique
93  _n_parts (other_mesh._n_parts),
94  _default_mapping_type(other_mesh._default_mapping_type),
95  _default_mapping_data(other_mesh._default_mapping_data),
96  _is_prepared (other_mesh._is_prepared),
97  _point_locator (),
98  _count_lower_dim_elems_in_point_locator(other_mesh._count_lower_dim_elems_in_point_locator),
99  _partitioner (),
100 #ifdef LIBMESH_ENABLE_UNIQUE_ID
101  _next_unique_id(other_mesh._next_unique_id),
102 #endif
104  _skip_all_partitioning(libMesh::on_command_line("--skip-partitioning")),
105  _skip_renumber_nodes_and_elements(other_mesh._skip_renumber_nodes_and_elements),
106  _skip_find_neighbors(other_mesh._skip_find_neighbors),
107  _allow_remote_element_removal(other_mesh._allow_remote_element_removal),
108  _elem_dims(other_mesh._elem_dims),
109  _elemset_codes_inverse_map(other_mesh._elemset_codes_inverse_map),
110  _all_elemset_ids(other_mesh._all_elemset_ids),
111  _spatial_dimension(other_mesh._spatial_dimension),
112  _default_ghosting(std::make_unique<GhostPointNeighbors>(*this)),
113  _point_locator_close_to_point_tol(other_mesh._point_locator_close_to_point_tol)
114 {
115  const GhostingFunctor * const other_default_ghosting = other_mesh._default_ghosting.get();
116 
117  for (GhostingFunctor * const gf : other_mesh._ghosting_functors)
118  {
119  // If the other mesh is using default ghosting, then we will use our own
120  // default ghosting
121  if (gf == other_default_ghosting)
122  {
124  continue;
125  }
126 
127  std::shared_ptr<GhostingFunctor> clone_gf = gf->clone();
128  // Some subclasses of GhostingFunctor might not override the
129  // clone function yet. If this is the case, GhostingFunctor will
130  // return nullptr by default. The clone function should be overridden
131  // in all derived classes. This following code ("else") is written
132  // for API upgrade. That will allow users gradually to update their code.
133  // Once the API upgrade is done, we will come back and delete "else."
134  if (clone_gf)
135  {
136  clone_gf->set_mesh(this);
137  add_ghosting_functor(clone_gf);
138  }
139  else
140  {
141  libmesh_deprecated();
143  }
144  }
145 
146  if (other_mesh._partitioner.get())
147  _partitioner = other_mesh._partitioner->clone();
148 
149  // _elemset_codes stores pointers to entries in _elemset_codes_inverse_map,
150  // so it is not possible to simply copy it directly from other_mesh
151  for (const auto & [set, code] : _elemset_codes_inverse_map)
152  _elemset_codes.emplace(code, &set);
153 }
ParallelObject(const Parallel::Communicator &comm_in)
Constructor.
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition: mesh_base.h:1868
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
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::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
friend class BoundaryInfo
Make the BoundaryInfo class a friend so that it can create and interact with BoundaryMesh.
Definition: mesh_base.h:2033
std::set< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition: mesh_base.h:1991
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
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
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
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
bool on_command_line(std::string arg)
Definition: libmesh.C:924
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
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
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

◆ MeshBase() [3/3]

libMesh::MeshBase::MeshBase ( MeshBase &&  )
delete

Move-constructor - deleted because after a theoretical move-construction and then destruction of the moved-from object, the moved BoundaryInfo would hold an invalid reference to the moved-from mesh.

◆ ~MeshBase()

libMesh::MeshBase::~MeshBase ( )
virtual

Destructor.

Definition at line 315 of file mesh_base.C.

References clear(), and libMesh::closed().

316 {
317  this->MeshBase::clear();
318 
319  libmesh_exceptionless_assert (!libMesh::closed());
320 }
bool closed()
Checks that the library has been closed.
Definition: libmesh.C:273
virtual void clear()
Deletes all the element and node data that is currently stored.
Definition: mesh_base.C:862

Member Function Documentation

◆ ABSTRACT_ELEM_ITERATORS() [1/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( )

◆ ABSTRACT_ELEM_ITERATORS() [2/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( ancestor_  )

◆ ABSTRACT_ELEM_ITERATORS() [3/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( local_  )

◆ ABSTRACT_ELEM_ITERATORS() [4/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( facelocal_  )

◆ ABSTRACT_ELEM_ITERATORS() [5/15]

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

◆ ABSTRACT_ELEM_ITERATORS() [6/15]

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

◆ ABSTRACT_ELEM_ITERATORS() [7/15]

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

◆ ABSTRACT_ELEM_ITERATORS() [8/15]

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

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

◆ ABSTRACT_ELEM_ITERATORS() [10/15]

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

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

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

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

◆ ABSTRACT_ELEM_ITERATORS() [14/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( semilocal_  )

◆ ABSTRACT_ELEM_ITERATORS() [15/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_semilocal_  )

◆ active_local_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::MeshBase::active_local_subdomain_elements_ptr_range ( subdomain_id_type  sid)
pure virtual

◆ active_local_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::MeshBase::active_local_subdomain_elements_ptr_range ( subdomain_id_type  sid) const
pure virtual

◆ active_subdomain_elements_ptr_range() [1/2]

unsigned int level ElemType type std::set<subdomain_id_type> ss processor_id_type pid unsigned int level std::set<subdomain_id_type> virtual ss SimpleRange<element_iterator> libMesh::MeshBase::active_subdomain_elements_ptr_range ( subdomain_id_type  sid)
pure virtual

◆ active_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::MeshBase::active_subdomain_elements_ptr_range ( subdomain_id_type  sid) const
pure virtual

◆ active_subdomain_set_elements_ptr_range() [1/2]

virtual SimpleRange<element_iterator> libMesh::MeshBase::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type ss)
pure virtual

◆ active_subdomain_set_elements_ptr_range() [2/2]

virtual SimpleRange<const_element_iterator> libMesh::MeshBase::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type ss) const
pure virtual

◆ add_elem() [1/2]

virtual Elem* libMesh::MeshBase::add_elem ( Elem e)
pure virtual

Add elem e to the end of the element array.

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

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

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

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), LinearElasticityWithContact::add_contact_edge_elements(), add_cube_convex_hull_to_mesh(), libMesh::MeshRefinement::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::mesh_inserter_iterator< T >::operator=(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), BoundaryInfoTest::testShellFaceConstraints(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and libMesh::TetGenMeshInterface::triangulate_pointset().

◆ add_elem() [2/2]

virtual Elem* libMesh::MeshBase::add_elem ( std::unique_ptr< Elem e)
pure virtual

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.

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

◆ 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 
)
inline

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 _elem_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and 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 
)
inline

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 _elem_integer_names, add_elem_integer(), libMesh::DofObject::invalid_id, and 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 
)

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 _elem_integer_default_values, _elem_integer_names, libMesh::index_range(), libMesh::Quality::name(), and size_elem_extra_integers().

Referenced by 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 
)

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 _elem_integer_default_values, _elem_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::Quality::name(), and size_elem_extra_integers().

Referenced by 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 
)

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 _all_elemset_ids, _elemset_codes, and _elemset_codes_inverse_map.

Referenced by 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_ghosting_functor() [1/2]

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

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 _ghosting_functors.

Referenced by libMesh::DofMap::add_algebraic_ghosting_functor(), libMesh::DofMap::add_coupling_functor(), add_ghosting_functor(), main(), 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)
inline

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 _shared_functors, and 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]

virtual Node* libMesh::MeshBase::add_node ( Node n)
pure virtual

◆ add_node() [2/2]

virtual Node* libMesh::MeshBase::add_node ( std::unique_ptr< Node n)
pure virtual

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.

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

◆ 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 
)
inline

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 _node_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and 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 
)
inline

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 _node_integer_names, add_node_integer(), libMesh::DofObject::invalid_id, and 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 
)

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 _node_integer_default_values, _node_integer_names, libMesh::index_range(), libMesh::Quality::name(), and size_node_extra_integers().

Referenced by 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 
)

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 _node_integer_default_values, _node_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::Quality::name(), and size_node_extra_integers().

Referenced by 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()

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

Add a new Node at Point p to the end of the vertex array, with processor_id procid.

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

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

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), add_cube_convex_hull_to_mesh(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::InfElemBuilder::build_inf_elem(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::nodes_in(), libMesh::mesh_inserter_iterator< T >::operator=(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::AbaqusIO::read_nodes(), libMesh::CheckpointIO::read_nodes(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::BoundaryInfo::sync(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), BoundaryInfoTest::testShellFaceConstraints(), MeshTriangulationTest::testTriangulator(), MeshTriangulationTest::testTriangulatorHoles(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorSegments(), MeshTriangulationTest::testTriangulatorTrapMesh(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and triangulate_domain().

◆ all_complete_order()

void libMesh::MeshBase::all_complete_order ( )
virtual

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

virtual void libMesh::MeshBase::all_complete_order_range ( const SimpleRange< element_iterator > &  range)
pure virtual

Converts a set of elements in this (conforming, non-refined) mesh into "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.

Implemented in libMesh::UnstructuredMesh.

Referenced by all_complete_order(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderMixedFixing(), AllSecondOrderTest::allCompleteOrderMixedFixing3D(), and AllSecondOrderTest::allCompleteOrderRange().

◆ all_first_order()

virtual void libMesh::MeshBase::all_first_order ( )
pure virtual

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

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

Implemented in libMesh::UnstructuredMesh.

Referenced by main(), and ExtraIntegersTest::test_helper().

◆ all_second_order()

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

Definition at line 1535 of file mesh_base.C.

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

virtual void libMesh::MeshBase::all_second_order_range ( const SimpleRange< element_iterator > &  range,
const bool  full_ordered = true 
)
pure virtual

Converts a set of this Mesh's elements defined by range from FIRST order to SECOND order.

Must be called on conforming, non-refined meshes. 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.

Implemented in libMesh::UnstructuredMesh.

Referenced by all_second_order(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderMixedFixing(), AllSecondOrderTest::allSecondOrderMixedFixing3D(), AllSecondOrderTest::allSecondOrderRange(), and MixedOrderTest::testFindNeighbors().

◆ allgather()

virtual void libMesh::MeshBase::allgather ( )
inlinevirtual

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 234 of file mesh_base.h.

Referenced by libMesh::EquationSystems::allgather(), libMesh::MeshSerializer::MeshSerializer(), and PartitionerTest< PartitionerSubclass, MeshClass >::testPartition().

234 {}

◆ allow_find_neighbors() [1/2]

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

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 _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
inline

Definition at line 1181 of file mesh_base.h.

References _skip_find_neighbors.

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

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

◆ allow_remote_element_removal() [1/2]

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

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 _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
inline

Definition at line 1190 of file mesh_base.h.

References _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)
inline

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 _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
inline

Definition at line 1174 of file mesh_base.h.

References _skip_renumber_nodes_and_elements.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), 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()

virtual MeshBase& libMesh::MeshBase::assign ( MeshBase &&  other_mesh)
pure virtual

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

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

Referenced by MeshAssignTest::testMeshMoveAssign().

◆ cache_elem_data()

void libMesh::MeshBase::cache_elem_data ( )

Definition at line 1662 of file mesh_base.C.

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

Referenced by cache_elem_dims(), prepare_for_use(), and 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 ( )

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

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 _elemset_codes, _elemset_codes_inverse_map, add_elemset_code(), get_elem_integer_index(), and 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 
)

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 _all_elemset_ids, _elemset_codes, and _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::MeshBase::clear ( )
virtual

Deletes all the element and node data that is currently stored.

elem and node extra_integer data is nevertheless retained here, for better compatibility between that feature and older code's use of MeshBase::clear()

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

Definition at line 862 of file mesh_base.C.

References _constraint_rows, _elem_dims, _elemset_codes, _elemset_codes_inverse_map, _is_prepared, _n_parts, boundary_info, and clear_point_locator().

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::ReplicatedMesh::clear(), libMesh::DistributedMesh::clear(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), main(), libMesh::AbaqusIO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::BoundaryInfo::sync(), MeshAssignTest::testMeshMoveAssign(), and ~MeshBase().

863 {
864  // Reset the number of partitions
865  _n_parts = 1;
866 
867  // Reset the _is_prepared flag
868  _is_prepared = false;
869 
870  // Clear boundary information
871  if (boundary_info)
872  boundary_info->clear();
873 
874  // Clear element dimensions
875  _elem_dims.clear();
876 
877  _elemset_codes.clear();
879 
880  _constraint_rows.clear();
881 
882  // Clear our point locator.
883  this->clear_point_locator();
884 }
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
std::unique_ptr< BoundaryInfo > boundary_info
This class holds the boundary information.
Definition: mesh_base.h:1760
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
unsigned int _n_parts
The number of partitions the mesh has.
Definition: mesh_base.h:1802
void clear_point_locator()
Releases the current PointLocator object.
Definition: mesh_base.C:1598
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition: mesh_base.h:1895
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820

◆ clear_elems()

virtual void libMesh::MeshBase::clear_elems ( )
pure virtual

Deletes all the element data that is currently stored.

No Node is removed from the mesh, however even NodeElem elements are deleted, so the remaining Nodes will be considered "unused" and cleared unless they are reconnected to new elements before the next prepare_for_use()

This does not affect BoundaryInfo data; any boundary information associated elements should already be cleared.

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

Referenced by libMesh::TriangulatorInterface::elems_to_segments(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

◆ clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )

Releases the current PointLocator object.

Definition at line 1598 of file mesh_base.C.

References _point_locator.

Referenced by clear(), libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), and 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::MeshBase::clone ( ) const
pure virtual

◆ 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(), 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(), 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(), 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(), 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(), 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(), 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(), 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()

virtual bool libMesh::MeshBase::contract ( )
pure virtual

Delete subactive (i.e.

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

Implemented in libMesh::UnstructuredMesh.

Referenced by libMesh::EquationSystems::reinit_solutions().

◆ copy_constraint_rows() [1/2]

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

Copy the constraints from the other mesh to this mesh.

Definition at line 1938 of file mesh_base.C.

References _constraint_rows, elem_ptr(), get_constraint_rows(), and 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)

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 _constraint_rows, add_elem(), add_point(), TIMPI::Communicator::allgather(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), 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(), n_nodes(), node_ptr(), 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

◆ default_ghosting()

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

Default ghosting functor.

Definition at line 1280 of file mesh_base.h.

References _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
inline

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

Definition at line 809 of file mesh_base.h.

References _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
inline

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

virtual void libMesh::MeshBase::delete_elem ( Elem e)
pure virtual

◆ delete_node()

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

◆ delete_remote_elements()

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

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 247 of file mesh_base.h.

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

247 {}

◆ detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )

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, elem_dimensions(), elem_ptr(), elem_ref(), libMesh::make_range(), and max_elem_id().

Referenced by 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
inline
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 _elem_dims.

Referenced by libMesh::System::calculate_norm(), 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]

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

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

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_elements(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::connect_families(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), detect_interior_parents(), libMesh::DTKAdapter::DTKAdapter(), elem_ref(), libMesh::DTKEvaluator::evaluate(), libMesh::ExodusII_IO_Helper::get_sideset_data_indices(), libMesh::UNVIO::groups_in(), libMesh::ErrorVector::is_active_elem(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), main(), LinearElasticityWithContact::move_mesh(), AugmentSparsityOnNodes::operator()(), libMesh::BoundaryInfo::operator=(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::query_ghosting_functors(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::UnstructuredMesh::stitching_helper(), VolumeTest::testHex20PLevelTrueCentroid(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), VolumeTest::testTwistedVolume(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_sideset_data(), and libMesh::ExodusII_IO_Helper::write_sidesets().

◆ elem_ptr() [2/2]

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

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

◆ elem_ref() [1/2]

virtual const Elem& libMesh::MeshBase::elem_ref ( const dof_id_type  i) const
inlinevirtual
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 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(), 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)
inlinevirtual
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 elem_ptr().

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

◆ find_neighbors()

virtual void libMesh::MeshBase::find_neighbors ( const bool  reset_remote_elements = false,
const bool  reset_current_list = true 
)
pure virtual

Locate element face (edge in 2D) neighbors.

This is done with the help of a std::map that functions like a hash table. After this routine is called all the elements with a nullptr neighbor pointer are guaranteed to be on the boundary. Thus this routine is useful for automatically determining the boundaries of the domain. If reset_remote_elements is left to false, remote neighbor links are not reset and searched for in the local mesh. If reset_current_list is left as true, then any existing links will be reset before initiating the algorithm, while honoring the value of the reset_remote_elements flag.

Implemented in libMesh::UnstructuredMesh.

Referenced by libMesh::InfElemBuilder::build_inf_elem(), main(), prepare_for_use(), MixedOrderTest::testFindNeighbors(), and tetrahedralize_domain().

◆ fix_broken_node_and_element_numbering()

virtual void libMesh::MeshBase::fix_broken_node_and_element_numbering ( )
pure virtual

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

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

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

Referenced by libMesh::EquationSystems::read(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), and libMesh::RBEvaluation::write_out_vectors().

◆ gather_to_zero()

virtual void libMesh::MeshBase::gather_to_zero ( )
inlinevirtual

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 240 of file mesh_base.h.

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

240 {}

◆ get_boundary_info() [1/2]

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

The information about boundary ids on the mesh.

Definition at line 159 of file mesh_base.h.

References 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(), 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(), 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 ( )
inline

Writable information about boundary ids on the mesh.

Definition at line 164 of file mesh_base.h.

References 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 ( )
inline

◆ get_constraint_rows() [2/2]

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

Definition at line 1686 of file mesh_base.h.

References _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

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 1612 of file mesh_base.C.

References _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

Definition at line 578 of file mesh_base.C.

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

Referenced by 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
inline

Definition at line 923 of file mesh_base.h.

References _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

Definition at line 391 of file mesh_base.C.

References _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

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 _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

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 _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
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 _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
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 _elem_dims, _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(), 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(), get_subdomain_name_map(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, is_prepared(), is_replicated(), libMesh::libmesh_assert(), libMesh::Elem::loose_bounding_box(), TIMPI::Communicator::max(), TIMPI::Communicator::min(), n_active_elem(), n_elem(), n_elemsets(), n_local_elem(), n_local_nodes(), n_local_subdomains(), n_nodes(), n_partitions(), libMesh::ParallelObject::n_processors(), n_subdomains(), libMesh::n_threads(), libMesh::Quality::name(), libMesh::Elem::node_ref_range(), libMesh::ParallelObject::processor_id(), libMesh::Real, TIMPI::Communicator::set_union(), spatial_dimension(), TIMPI::Communicator::sum(), libMesh::Elem::type(), libMesh::BoundingBox::union_with(), and libMesh::Elem::volume().

Referenced by 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
inline
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 _mesh_subdomains, 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

Definition at line 667 of file mesh_base.C.

References _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
inline

Definition at line 1045 of file mesh_base.h.

References _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

Definition at line 1836 of file mesh_base.C.

References _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
inline

Definition at line 1671 of file mesh_base.h.

References _block_id_to_name.

Referenced by libMesh::DistributedMesh::DistributedMesh(), 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
inline

Beginning of range of ghosting functors.

Definition at line 1268 of file mesh_base.h.

References _ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), 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
inline

End of range of ghosting functors.

Definition at line 1274 of file mesh_base.h.

References _ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), 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

Definition at line 590 of file mesh_base.C.

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

Referenced by 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

Definition at line 679 of file mesh_base.C.

References _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]

virtual Elem* libMesh::MeshBase::insert_elem ( Elem e)
pure virtual

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

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

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

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::MeshTools::Subdivision::all_subdivision().

◆ insert_elem() [2/2]

virtual Elem* libMesh::MeshBase::insert_elem ( std::unique_ptr< Elem e)
pure virtual

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.

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

◆ insert_node() [1/2]

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

This method is deprecated.

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

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

Referenced by libMesh::mesh_inserter_iterator< T >::operator=().

◆ insert_node() [2/2]

virtual Node* libMesh::MeshBase::insert_node ( std::unique_ptr< Node n)
pure virtual

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.

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

◆ is_prepared()

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

Definition at line 192 of file mesh_base.h.

References _is_prepared.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::flatten(), libMesh::BoundaryInfo::get_global_boundary_ids(), get_info(), get_mesh_subdomains(), and libMesh::MeshTools::valid_is_prepared().

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

◆ is_replicated()

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 227 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), get_info(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::CheckpointIO::read(), and libMesh::MeshRefinement::uniformly_coarsen().

228  { return true; }

◆ is_serial()

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 205 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::allgather(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshTools::build_nodes_to_elem_map(), cache_elem_data(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::LocationMap< T >::init(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshSerializer::MeshSerializer(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), partition(), prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::BoundaryInfo::regenerate_id_sets(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::BoundaryInfo::sync(), MeshInputTest::testExodusIGASidesets(), PointLocatorTest::testLocator(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), BoundaryInfoTest::testRenumber(), MeshInputTest::testTetgenIO(), WriteNodesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::CheckpointIO::write(), and libMesh::XdrIO::write_parallel().

206  { return true; }

◆ is_serial_on_zero()

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 212 of file mesh_base.h.

Referenced by libMesh::ExodusII_IO::copy_elemental_solution(), and libMesh::ExodusII_IO::copy_nodal_solution().

213  { return true; }

◆ libmesh_assert_valid_parallel_ids()

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

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

Calls libmesh_assert() on each possible failure. Currently only implemented on DistributedMesh; a serial data structure is much harder to get out of sync.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1493 of file mesh_base.h.

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

1493 {}

◆ locally_equals()

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

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

Definition at line 222 of file mesh_base.C.

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

Referenced by 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::MeshBase::max_elem_id ( ) const
pure virtual
Returns
A number greater than or equal to the maximum element id in the mesh.

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

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), CopyNodesAndElementsTest::collectMeshes(), libMesh::MeshCommunication::delete_remote_elements(), detect_interior_parents(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), 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::MeshTools::libmesh_assert_valid_unique_ids(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::MeshTools::Modification::permute_elements(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::UnstructuredMesh::stitching_helper(), EquationSystemsTest::testPostInitAddElem(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testVTKPreserveElemIds(), libMesh::ExodusII_IO_Helper::write_elements(), and libMesh::GmshIO::write_mesh().

◆ max_node_id()

virtual dof_id_type libMesh::MeshBase::max_node_id ( ) const
pure virtual

◆ merge_extra_integer_names()

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

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 _elem_integer_default_values, _elem_integer_names, _node_integer_default_values, _node_integer_names, add_elem_integers(), and 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
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 _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(), 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

◆ n_active_elem()

virtual dof_id_type libMesh::MeshBase::n_active_elem ( ) const
pure virtual

◆ n_active_elem_on_proc()

dof_id_type libMesh::MeshBase::n_active_elem_on_proc ( const processor_id_type  proc) const
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 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
inline
Returns
The number of active elements on the local processor.

Definition at line 544 of file mesh_base.h.

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::Partitioner::assign_partitioning(), libMesh::Partitioner::build_graph(), libMesh::VTKIO::cells_to_vtk(), and BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen().

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

◆ n_active_sub_elem()

dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const

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::MeshBase::n_elem ( ) const
pure virtual
Returns
The number of elements in the mesh.

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

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

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::TetGenMeshInterface::check_hull_integrity(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::distort(), libMesh::TriangulatorInterface::elems_to_segments(), get_info(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshTools::Modification::redistribute(), ConstraintOperatorTest::test1DCoarseningNewNodes(), AllTriTest::test_helper_2D(), AllTriTest::test_helper_3D(), MeshInputTest::testAbaqusRead(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), MeshGenerationTest::testBuildSquare(), MeshDeletionsTest::testDeleteElem(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusIGASidesets(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), MeshAssignTest::testMeshMoveAssign(), MeshInputTest::testNemesisReadImpl(), MeshTriangulationTest::testPoly2TriRefinementBase(), EquationSystemsTest::testSelectivePRefine(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorBase(), MeshTriangulationTest::testTriangulatorHoles(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::XdrIO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_nodal_data(), libMesh::XdrIO::write_serialized_connectivity(), and libMesh::System::write_serialized_vectors().

◆ n_elem_integers()

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

Definition at line 934 of file mesh_base.h.

References _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
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 n_local_elem(), and 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

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 _all_elemset_ids.

Referenced by 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
inline
Returns
The number of elements on the local processor.

Definition at line 527 of file mesh_base.h.

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

Referenced by libMesh::DTKAdapter::DTKAdapter(), 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
inline
Returns
The number of nodes on the local processor.

Definition at line 421 of file mesh_base.h.

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

Referenced by 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
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 subdomain_ids().

Referenced by 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
inline

Definition at line 1056 of file mesh_base.h.

References _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::MeshBase::n_nodes ( ) const
pure virtual
Returns
The number of nodes in the mesh.

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

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

Referenced by libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::distort(), fill_dirichlet_bc(), libMesh::TetGenMeshInterface::fill_pointlist(), get_info(), libMesh::VTKIO::get_local_node_values(), libMesh::TreeNode< N >::insert(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), main(), libMesh::VariationalMeshSmoother::metr_data_gen(), AllSecondOrderTest::MixedFixingImpl(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshTools::Modification::redistribute(), libMesh::VariationalMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), ConstraintOperatorTest::test1DCoarseningNewNodes(), MeshInputTest::testAbaqusRead(), SystemsTest::testBoundaryProjectCube(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), MeshGenerationTest::testBuildSquare(), SystemsTest::testDofCouplingWithVarGroups(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), VolumeTest::testEdge3Volume(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testNemesisReadImpl(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), libMesh::DirectSolutionTransfer::transfer(), libMesh::TreeNode< N >::transform_nodes_to_elements(), libMesh::TriangleInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::UCDIO::write_header(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::GmshIO::write_post(), libMesh::System::write_serialized_vectors(), libMesh::UCDIO::write_soln(), and libMesh::VariationalMeshSmoother::writegr().

◆ n_nodes_on_proc()

dof_id_type libMesh::MeshBase::n_nodes_on_proc ( const processor_id_type  proc) const
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 n_local_nodes(), and 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
inline
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 _n_parts.

Referenced by libMesh::Partitioner::assign_partitioning(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), 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(), 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(), n_active_elem_on_proc(), n_elem_on_proc(), n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), 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
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
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 subdomain_ids().

Referenced by 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
inline
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 n_elem_on_proc().

Referenced by libMesh::DistributedMesh::parallel_n_elem(), and 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
inline
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 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 ( )
inline
Returns
The next unique id to be used.

Definition at line 440 of file mesh_base.h.

References _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]

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

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

Referenced by libMesh::GMVIO::_read_one_cell(), add_cube_convex_hull_to_mesh(), libMesh::MeshRefinement::add_node(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), libMesh::DofMap::allgather_recursive_constraints(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::TetGenIO::element_in(), libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), main(), node_ref(), libMesh::BoundaryInfo::operator=(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::DofMap::scatter_constraints(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), NodalNeighborsTest::testOrientation(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), BoundaryInfoTest::testShellFaceConstraints(), MeshSubdomainIDTest::testUnpartitioned(), and libMesh::CheckpointIO::write_nodesets().

◆ node_ptr() [2/2]

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

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

◆ node_ref() [1/2]

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

◆ node_ref() [2/2]

virtual Node& libMesh::MeshBase::node_ref ( const dof_id_type  i)
inlinevirtual
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 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
protected

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 query_elem_ptr(), and 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
inline

Definition at line 128 of file mesh_base.h.

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

◆ operator=() [1/2]

MeshBase& libMesh::MeshBase::operator= ( const MeshBase )
delete

Copy and move assignment are not allowed because MeshBase subclasses manually manage memory (Elems and Nodes) and therefore the default versions of these operators would leak memory.

Since we don't want to maintain non-default copy and move assignment operators at this time, the safest and most self-documenting approach is to delete them.

If you need to copy a Mesh, use the clone() method.

◆ operator=() [2/2]

MeshBase & libMesh::MeshBase::operator= ( MeshBase &&  other_mesh)

Definition at line 155 of file mesh_base.C.

References _all_elemset_ids, _allow_remote_element_removal, _block_id_to_name, _count_lower_dim_elems_in_point_locator, _default_mapping_data, _default_mapping_type, _elem_dims, _elem_integer_default_values, _elem_integer_names, _elemset_codes, _elemset_codes_inverse_map, _is_prepared, _n_parts, _next_unique_id, _node_integer_default_values, _node_integer_names, _point_locator, _point_locator_close_to_point_tol, _skip_all_partitioning, _skip_find_neighbors, _skip_noncritical_partitioning, _skip_renumber_nodes_and_elements, _spatial_dimension, boundary_info, and libMesh::ParallelObject::operator=().

156 {
157  LOG_SCOPE("operator=(&&)", "MeshBase");
158 
159  // Move assign as a ParallelObject.
160  this->ParallelObject::operator=(other_mesh);
161 
162  _n_parts = other_mesh.n_partitions();
163  _default_mapping_type = other_mesh.default_mapping_type();
164  _default_mapping_data = other_mesh.default_mapping_data();
165  _is_prepared = other_mesh.is_prepared();
166  _point_locator = std::move(other_mesh._point_locator);
167  _count_lower_dim_elems_in_point_locator = other_mesh.get_count_lower_dim_elems_in_point_locator();
168  #ifdef LIBMESH_ENABLE_UNIQUE_ID
169  _next_unique_id = other_mesh.next_unique_id();
170  #endif
171  _skip_noncritical_partitioning = other_mesh.skip_noncritical_partitioning();
172  _skip_all_partitioning = other_mesh.skip_partitioning();
173  _skip_renumber_nodes_and_elements = !(other_mesh.allow_renumbering());
174  _skip_find_neighbors = !(other_mesh.allow_find_neighbors());
175  _allow_remote_element_removal = other_mesh.allow_remote_element_removal();
176  _block_id_to_name = std::move(other_mesh._block_id_to_name);
177  _elem_dims = std::move(other_mesh.elem_dimensions());
178  _elemset_codes = std::move(other_mesh._elemset_codes);
179  _elemset_codes_inverse_map = std::move(other_mesh._elemset_codes_inverse_map);
180  _all_elemset_ids = std::move(other_mesh._all_elemset_ids),
181  _spatial_dimension = other_mesh.spatial_dimension();
182  _elem_integer_names = std::move(other_mesh._elem_integer_names);
183  _elem_integer_default_values = std::move(other_mesh._elem_integer_default_values);
184  _node_integer_names = std::move(other_mesh._node_integer_names);
185  _node_integer_default_values = std::move(other_mesh._node_integer_default_values);
186  _point_locator_close_to_point_tol = other_mesh.get_point_locator_close_to_point_tol();
187 
188  // This relies on our subclasses *not* invalidating pointers when we
189  // do their portion of the move assignment later!
190  boundary_info = std::move(other_mesh.boundary_info);
191  boundary_info->set_mesh(*this);
192 
193 #ifdef DEBUG
194  // Make sure that move assignment worked for pointers
195  for (const auto & [set, code] : _elemset_codes_inverse_map)
196  {
197  auto it = _elemset_codes.find(code);
198  libmesh_assert_msg(it != _elemset_codes.end(),
199  "Elemset code " << code << " not found in _elmset_codes container.");
200  libmesh_assert_equal_to(it->second, &set);
201  }
202 #endif
203 
204  // We're *not* really done at this point, but we have the problem
205  // that some of our data movement might be expecting subclasses data
206  // movement to happen first. We'll let subclasses handle that by
207  // calling our post_dofobject_moves()
208  return *this;
209 }
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
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::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition: mesh_base.h:1925
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
ParallelObject & operator=(const ParallelObject &libmesh_dbg_var(other))
"Assignment" operator.
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition: mesh_base.h:1849
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
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
bool _is_prepared
Flag indicating if the mesh has been prepared for use.
Definition: mesh_base.h:1820
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition: mesh_base.h:1861
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
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

◆ operator==()

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

Definition at line 212 of file mesh_base.C.

References libMesh::ParallelObject::comm(), 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()

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

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 719 of file mesh_base.h.

719 {}

◆ parallel_max_unique_id()

virtual unique_id_type libMesh::MeshBase::parallel_max_unique_id ( ) const
pure virtual

◆ parallel_n_elem()

virtual dof_id_type libMesh::MeshBase::parallel_n_elem ( ) const
pure virtual
Returns
The number of elements in the mesh.

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

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

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

◆ parallel_n_nodes()

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

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

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

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

◆ partition() [1/2]

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

Call the default partitioner (currently metis_partition()).

Definition at line 1503 of file mesh_base.C.

References libMesh::MeshTools::correct_node_proc_ids(), is_serial(), libMesh::libmesh_assert(), n_unpartitioned_elem(), partitioner(), recalculate_n_partitions(), skip_noncritical_partitioning(), and 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 ( )
inline

Definition at line 1139 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

Referenced by prepare_for_use().

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

◆ partitioner()

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

A partitioner to use at each prepare_for_use()

Definition at line 154 of file mesh_base.h.

References _partitioner.

Referenced by main(), 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()

virtual const Point& libMesh::MeshBase::point ( const dof_id_type  i) const
pure virtual

◆ post_dofobject_moves()

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

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 _constraint_rows, _default_ghosting, _ghosting_functors, _partitioner, and _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 
)

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 allow_find_neighbors(), allow_renumbering(), and 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)

Definition at line 729 of file mesh_base.C.

References allow_renumbering(), and 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 ( )

Definition at line 742 of file mesh_base.C.

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

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), 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

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 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(), 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(), n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), n_local_elem(), 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]

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

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

Referenced by libMesh::connect_families(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), 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_unique_ids(), libMesh::MeshCommunication::make_elems_parallel_consistent(), nodes_and_elements_equal(), libMesh::BoundaryInfo::operator==(), libMesh::MeshTools::Modification::permute_elements(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_bcs_helper(), ParsedFEMFunctionTest::setUp(), MeshDeletionsTest::testDeleteElem(), VolumeTest::testEdge3Volume(), ExtraIntegersTest::testExtraIntegersExodusReading(), MeshBaseTest::testMeshBaseVerifyIsPrepared(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testSelectivePRefine(), BoundaryInfoTest::testShellFaceConstraints(), and MeshInputTest::testTetgenIO().

◆ query_elem_ptr() [2/2]

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

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

◆ query_node_ptr() [1/2]

virtual const Node* libMesh::MeshBase::query_node_ptr ( const dof_id_type  i) const
pure virtual

◆ query_node_ptr() [2/2]

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

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

◆ read()

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

Interfaces for reading/writing a mesh to/from a file.

Must be implemented in derived classes.

Implemented in libMesh::UnstructuredMesh.

Referenced by build_domain(), main(), BoundaryInfoTest::testEdgeBoundaryConditions(), PeriodicBCTest::testPeriodicBC(), MeshInputTest::testVTKPreserveElemIds(), and MeshInputTest::testVTKPreserveSubdomainIds().

◆ recalculate_n_partitions()

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

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 _n_parts, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by 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::MeshBase::redistribute ( )
virtual

Redistribute elements between processors.

This gets called automatically by the Partitioner, and merely notifies any GhostingFunctors of redistribution in the case of a ReplicatedMesh or serialized DistributedMesh

Reimplemented in libMesh::DistributedMesh.

Definition at line 925 of file mesh_base.C.

References libMesh::as_range(), ghosting_functors_begin(), and ghosting_functors_end().

Referenced by libMesh::Partitioner::partition(), libMesh::DistributedMesh::redistribute(), and libMesh::Partitioner::single_partition().

926 {
927  // We now have all elements and nodes redistributed; our ghosting
928  // functors should be ready to redistribute and/or recompute any
929  // cached data they use too.
930  for (auto & gf : as_range(this->ghosting_functors_begin(),
931  this->ghosting_functors_end()))
932  gf->redistribute();
933 }
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
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Beginning of range of ghosting functors.
Definition: mesh_base.h:1268
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
End of range of ghosting functors.
Definition: mesh_base.h:1274

◆ reinit_ghosting_functors()

void libMesh::MeshBase::reinit_ghosting_functors ( )

Loops over ghosting functors and calls mesh_reinit()

Definition at line 853 of file mesh_base.C.

References _ghosting_functors, and libMesh::libmesh_assert().

Referenced by 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)

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

Definition at line 888 of file mesh_base.C.

References _ghosting_functors, and _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 ( )

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

Referenced by 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_elem()

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

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

No element with the id new_id should already exist.

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

Referenced by libMesh::MeshCommunication::make_elems_parallel_consistent(), and MeshInputTest::testVTKPreserveElemIds().

◆ renumber_node()

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

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.

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

◆ renumber_nodes_and_elements()

virtual void libMesh::MeshBase::renumber_nodes_and_elements ( )
pure virtual

After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contiguous blocks on the processors.

This method does just that.

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

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::contract(), prepare_for_use(), and write_output().

◆ reserve_elem()

virtual void libMesh::MeshBase::reserve_elem ( const dof_id_type  ne)
pure virtual

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.

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

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), and libMesh::GmshIO::read_mesh().

◆ reserve_nodes()

virtual void libMesh::MeshBase::reserve_nodes ( const dof_id_type  nn)
pure virtual

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.

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

Referenced by libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), and libMesh::GmshIO::read_mesh().

◆ set_count_lower_dim_elems_in_point_locator()

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

Definition at line 1605 of file mesh_base.C.

References _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)
inline

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 _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)
inline

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 _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::MeshBase::set_distributed ( )
inlinevirtual

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

Only valid to call on classes which can be created in a distributed form.

Reimplemented in libMesh::DistributedMesh.

Definition at line 220 of file mesh_base.h.

Referenced by libMesh::CheckpointIO::read().

221  { libmesh_error(); }

◆ set_elem_dimensions()

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

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 _elem_dims, and 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 ( )
inline

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 _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)
inline

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 _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 ( )
inlineprotected
Returns
A writable reference to the number of partitions.

Definition at line 1789 of file mesh_base.h.

References _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()

virtual void libMesh::MeshBase::set_next_unique_id ( unique_id_type  id)
pure virtual

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.

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

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::Nemesis_IO::read(), and libMesh::XdrIO::read_serialized_nodes().

◆ set_point_locator_close_to_point_tol()

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

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 _point_locator, and _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)

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 _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 ( )
inline

Definition at line 1669 of file mesh_base.h.

References _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 ( )
protected

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

Definition at line 1843 of file mesh_base.C.

References _elem_integer_default_values, and _elem_integer_names.

Referenced by add_elem_data(), add_elem_datum(), add_elem_integer(), and 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 ( )
protected

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

Definition at line 1852 of file mesh_base.C.

References _node_integer_default_values, and _node_integer_names.

Referenced by add_node_data(), add_node_datum(), add_node_integer(), and 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)
inline

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 _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
inline

Definition at line 1216 of file mesh_base.h.

References _partitioner, _skip_all_partitioning, and _skip_noncritical_partitioning.

Referenced by 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)
inline

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 _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
inline

Definition at line 1233 of file mesh_base.h.

References _skip_all_partitioning.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and 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
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 _spatial_dimension.

Referenced by 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

◆ sub_point_locator()

std::unique_ptr< PointLocatorBase > libMesh::MeshBase::sub_point_locator ( ) const
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 _point_locator, _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()

virtual bool libMesh::MeshBase::subclass_locally_equals ( const MeshBase other_mesh) const
protectedpure virtual

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

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

Referenced by locally_equals().

◆ subdomain_ids()

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

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(), n_local_subdomains(), 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)
Returns
A writable reference for getting/setting an optional name for a subdomain.

Definition at line 1619 of file mesh_base.C.

References _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

Definition at line 1624 of file mesh_base.C.

References _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()

virtual void libMesh::MeshBase::update_parallel_id_counts ( )
pure virtual

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

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

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshRefinement::_refine_elements(), and prepare_for_use().

◆ update_post_partitioning()

virtual void libMesh::MeshBase::update_post_partitioning ( )
inlinevirtual

Recalculate any cached data after elements and nodes have been repartitioned.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1154 of file mesh_base.h.

Referenced by libMesh::Partitioner::partition(), partition(), and libMesh::Nemesis_IO::read().

1154 {}

◆ write()

virtual void libMesh::MeshBase::write ( const std::string &  name)
pure virtual

Friends And Related Function Documentation

◆ BoundaryInfo

friend class BoundaryInfo
friend

Make the BoundaryInfo class a friend so that it can create and interact with BoundaryMesh.

Definition at line 2033 of file mesh_base.h.

◆ MeshCommunication

friend class MeshCommunication
friend

Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.

Definition at line 2039 of file mesh_base.h.

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

◆ MeshInput< MeshBase >

friend class MeshInput< MeshBase >
friend

The MeshInput classes are friends so that they can set the number of partitions.

Definition at line 2027 of file mesh_base.h.

◆ operator<<

std::ostream& operator<< ( std::ostream &  os,
const MeshBase m 
)
friend

Equivalent to calling print_info() above, but now you can write: Mesh mesh; libMesh::out << mesh << std::endl;.

Definition at line 1496 of file mesh_base.C.

1497 {
1498  m.print_info(os);
1499  return os;
1500 }

◆ Partitioner

friend class Partitioner
friend

The partitioner class is a friend so that it can set the number of partitions.

Definition at line 2021 of file mesh_base.h.

Member Data Documentation

◆ _all_elemset_ids

MeshBase::elemset_type libMesh::MeshBase::_all_elemset_ids
protected

◆ _allow_remote_element_removal

bool libMesh::MeshBase::_allow_remote_element_removal
protected

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 allow_remote_element_removal(), locally_equals(), operator=(), and prepare_for_use().

◆ _block_id_to_name

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

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 get_id_by_name(), get_subdomain_name_map(), locally_equals(), operator=(), set_subdomain_name_map(), and subdomain_name().

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited

◆ _constraint_rows

constraint_rows_type libMesh::MeshBase::_constraint_rows
protected

◆ _count_lower_dim_elems_in_point_locator

bool libMesh::MeshBase::_count_lower_dim_elems_in_point_locator
protected

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 get_count_lower_dim_elems_in_point_locator(), locally_equals(), operator=(), and set_count_lower_dim_elems_in_point_locator().

◆ _default_ghosting

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

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 default_ghosting(), locally_equals(), MeshBase(), and post_dofobject_moves().

◆ _default_mapping_data

unsigned char libMesh::MeshBase::_default_mapping_data
protected

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 default_mapping_data(), locally_equals(), operator=(), and set_default_mapping_data().

◆ _default_mapping_type

ElemMappingType libMesh::MeshBase::_default_mapping_type
protected

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 default_mapping_type(), locally_equals(), operator=(), and set_default_mapping_type().

◆ _elem_dims

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

We cache the dimension of the elements present in the mesh.

So, if we have a mesh with 1D and 2D elements, this structure will contain 1 and 2.

Definition at line 1895 of file mesh_base.h.

Referenced by cache_elem_data(), clear(), elem_dimensions(), get_info(), locally_equals(), mesh_dimension(), MeshBase(), operator=(), set_elem_dimensions(), and set_mesh_dimension().

◆ _elem_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_elem_integer_default_values
protected

◆ _elem_integer_names

std::vector<std::string> libMesh::MeshBase::_elem_integer_names
protected

◆ _elemset_codes

std::map<dof_id_type, const MeshBase::elemset_type *> libMesh::MeshBase::_elemset_codes
protected

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 add_elemset_code(), change_elemset_code(), change_elemset_id(), clear(), get_elemset_codes(), get_elemsets(), get_info(), locally_equals(), MeshBase(), and operator=().

◆ _elemset_codes_inverse_map

std::map<MeshBase::elemset_type, dof_id_type> libMesh::MeshBase::_elemset_codes_inverse_map
protected

◆ _ghosting_functors

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

The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.

Basically unused by ReplicatedMesh for now, but belongs to MeshBase because the cost is trivial.

Definition at line 1991 of file mesh_base.h.

Referenced by add_ghosting_functor(), ghosting_functors_begin(), ghosting_functors_end(), locally_equals(), MeshBase(), post_dofobject_moves(), reinit_ghosting_functors(), and remove_ghosting_functor().

◆ _is_prepared

bool libMesh::MeshBase::_is_prepared
protected

Flag indicating if the mesh has been prepared for use.

Definition at line 1820 of file mesh_base.h.

Referenced by libMesh::UnstructuredMesh::all_first_order(), clear(), is_prepared(), locally_equals(), operator=(), prepare_for_use(), and set_isnt_prepared().

◆ _mesh_subdomains

std::set<subdomain_id_type> libMesh::MeshBase::_mesh_subdomains
protected

We cache the subdomain ids of the elements present in the mesh.

Definition at line 1900 of file mesh_base.h.

Referenced by cache_elem_data(), get_mesh_subdomains(), and locally_equals().

◆ _n_parts

unsigned int libMesh::MeshBase::_n_parts
protected

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 clear(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), locally_equals(), n_partitions(), operator=(), recalculate_n_partitions(), and set_n_partitions().

◆ _next_unique_id

unique_id_type libMesh::MeshBase::_next_unique_id
protected

◆ _node_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_node_integer_default_values
protected

◆ _node_integer_names

std::vector<std::string> libMesh::MeshBase::_node_integer_names
protected

◆ _partitioner

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

A partitioner to use at each prepare_for_use().

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

Definition at line 1843 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::DistributedMesh(), locally_equals(), MeshBase(), partitioner(), post_dofobject_moves(), libMesh::ReplicatedMesh::ReplicatedMesh(), and skip_noncritical_partitioning().

◆ _point_locator

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

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 clear_point_locator(), operator=(), set_point_locator_close_to_point_tol(), and sub_point_locator().

◆ _point_locator_close_to_point_tol

Real libMesh::MeshBase::_point_locator_close_to_point_tol
protected

If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we create.

Definition at line 2015 of file mesh_base.h.

Referenced by get_point_locator_close_to_point_tol(), locally_equals(), operator=(), set_point_locator_close_to_point_tol(), and sub_point_locator().

◆ _shared_functors

std::map<GhostingFunctor *, std::shared_ptr<GhostingFunctor> > libMesh::MeshBase::_shared_functors
protected

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 add_ghosting_functor(), post_dofobject_moves(), and remove_ghosting_functor().

◆ _skip_all_partitioning

bool libMesh::MeshBase::_skip_all_partitioning
protected

If this is true then no partitioning should be done.

Definition at line 1861 of file mesh_base.h.

Referenced by locally_equals(), operator=(), skip_noncritical_partitioning(), and skip_partitioning().

◆ _skip_find_neighbors

bool libMesh::MeshBase::_skip_find_neighbors
protected

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 allow_find_neighbors(), locally_equals(), operator=(), and prepare_for_use().

◆ _skip_noncritical_partitioning

bool libMesh::MeshBase::_skip_noncritical_partitioning
protected

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 locally_equals(), operator=(), and skip_noncritical_partitioning().

◆ _skip_renumber_nodes_and_elements

bool libMesh::MeshBase::_skip_renumber_nodes_and_elements
protected

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

This is set when prepare_for_use() is called.

Definition at line 1868 of file mesh_base.h.

Referenced by allow_renumbering(), locally_equals(), operator=(), prepare_for_use(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

◆ _spatial_dimension

unsigned char libMesh::MeshBase::_spatial_dimension
protected

The "spatial dimension" of the Mesh.

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

Definition at line 1932 of file mesh_base.h.

Referenced by cache_elem_data(), locally_equals(), operator=(), set_spatial_dimension(), and spatial_dimension().

◆ boundary_info

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

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 clear(), get_boundary_info(), locally_equals(), and operator=().

◆ var_num

const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::MeshBase::var_num
Initial value:
ABSTRACT_ELEM_ITERATORS(multi_evaluable_,std::vector<const DofMap *> dof_maps)
#ifdef LIBMESH_ENABLE_AMR
ABSTRACT_ELEM_ITERATORS(flagged_,unsigned char rflag)
ABSTRACT_ELEM_ITERATORS(flagged_pid_,unsigned char rflag LIBMESH_COMMA processor_id_type pid)
#endif
ABSTRACT_NODE_ITERATORS(,)
ABSTRACT_NODE_ITERATORS(active_,)
ABSTRACT_NODE_ITERATORS(local_,)
ABSTRACT_NODE_ITERATORS(bnd_,)
ABSTRACT_NODE_ITERATORS(pid_,processor_id_type pid)
ABSTRACT_NODE_ITERATORS(bid_,boundary_id_type bid)
ABSTRACT_NODE_ITERATORS(evaluable_,const DofMap & dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint)
ABSTRACT_NODE_ITERATORS(multi_evaluable_,std::vector<const DofMap *> dof_maps)

Definition at line 1621 of file mesh_base.h.


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