libMesh
Loading...
Searching...
No Matches
mesh_base.h
Go to the documentation of this file.
1// The libMesh Finite Element Library.
2// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3
4// This library is free software; you can redistribute it and/or
5// modify it under the terms of the GNU Lesser General Public
6// License as published by the Free Software Foundation; either
7// version 2.1 of the License, or (at your option) any later version.
8
9// This library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12// Lesser General Public License for more details.
13
14// You should have received a copy of the GNU Lesser General Public
15// License along with this library; if not, write to the Free Software
16// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
19
20#ifndef LIBMESH_MESH_BASE_H
21#define LIBMESH_MESH_BASE_H
22
23// Local Includes
24#include "libmesh/dof_object.h" // for invalid_processor_id
25#include "libmesh/enum_order.h"
26#include "libmesh/int_range.h"
27#include "libmesh/libmesh_common.h"
28#include "libmesh/multi_predicates.h"
29#include "libmesh/point_locator_base.h"
30#include "libmesh/variant_filter_iterator.h"
31#include "libmesh/parallel_object.h"
32#include "libmesh/simple_range.h"
33
34// C++ Includes
35#include <cstddef>
36#include <string>
37#include <memory>
38
39#include "libmesh/vector_value.h"
40
41namespace libMesh
42{
43// Forward declarations
44class BoundaryInfo;
45class Elem;
46class GhostingFunctor;
47class Node;
48class Point;
49class Partitioner;
50class PeriodicBoundary;
51class PeriodicBoundaries;
52
53template <typename T>
54class SparseMatrix;
55
56enum ElemType : int;
57enum ElemMappingType : unsigned char;
58
59template <class MT>
60class MeshInput;
61
62template <typename iterator_type, typename object_type>
63class StoredRange;
64
81{
82public:
83
89 MeshBase (const Parallel::Communicator & comm_in,
90 unsigned char dim=1);
91
95 MeshBase (const MeshBase & other_mesh);
96
102 MeshBase(MeshBase &&) = delete;
103
114 MeshBase & operator= (const MeshBase &) = delete;
115 MeshBase & operator= (MeshBase && other_mesh);
116
121 virtual MeshBase & assign(MeshBase && other_mesh) = 0;
122
136 bool operator== (const MeshBase & other_mesh) const;
137
138 bool operator!= (const MeshBase & other_mesh) const
139 {
140 return !(*this == other_mesh);
141 }
142
148 bool locally_equals (const MeshBase & other_mesh) const;
149
155 virtual std::unique_ptr<MeshBase> clone() const = 0;
156
160 virtual ~MeshBase ();
161
165 virtual std::unique_ptr<Partitioner> & partitioner() { return _partitioner; }
166
170 const BoundaryInfo & get_boundary_info() const { return *boundary_info; }
171
176
184 virtual void clear ();
185
197 virtual void clear_elems () = 0;
198
204 bool is_prepared () const;
205
211 struct Preparation;
212
214 { return _preparation; }
215
216#ifdef LIBMESH_ENABLE_DEPRECATED
229 { libmesh_deprecated(); _preparation = false; }
230#endif // LIBMESH_ENABLE_DEPRECATED
231
237 void unset_is_prepared();
238
248
259
272
283
295
309
320
332
342
352
357 virtual bool is_serial () const
358 { return true; }
359
364 virtual bool is_serial_on_zero () const
365 { return true; }
366
372 virtual void set_distributed ()
373 { libmesh_error(); }
374
379 virtual bool is_replicated () const
380 { return true; }
381
386 virtual void allgather () {}
387
392 virtual void gather_to_zero() {}
393
402
407
414 unsigned int mesh_dimension () const;
415
423 void set_mesh_dimension (unsigned char d)
424 { _elem_dims.clear(); _elem_dims.insert(d); }
425
430 const std::set<unsigned char> & elem_dimensions() const;
431
436 const std::set<Order> & elem_default_orders() const;
437
444
455 void set_elem_dimensions(std::set<unsigned char> elem_dims);
456
463 typedef std::set<elemset_id_type> elemset_type;
464
487
493 unsigned int n_elemsets() const;
494
501 void get_elemsets(dof_id_type elemset_code, MeshBase::elemset_type & id_set_to_fill) const;
503
508 std::vector<dof_id_type> get_elemset_codes() const;
509
516 void change_elemset_code(dof_id_type old_code, dof_id_type new_code);
517
523
550 unsigned int spatial_dimension () const;
551
556 void set_spatial_dimension(unsigned char d);
557
567 virtual dof_id_type n_nodes () const = 0;
568
578 virtual dof_id_type parallel_n_nodes () const = 0;
579
584
589 { return this->n_nodes_on_proc (this->processor_id()); }
590
596
601 virtual dof_id_type max_node_id () const = 0;
602
603#ifdef LIBMESH_ENABLE_UNIQUE_ID
608
618 virtual void set_next_unique_id(unique_id_type id) = 0;
619#endif
620
629 virtual void reserve_nodes (const dof_id_type nn) = 0;
630
638 virtual dof_id_type n_elem () const = 0;
639
647 virtual dof_id_type parallel_n_elem () const = 0;
648
653 virtual dof_id_type max_elem_id () const = 0;
654
659#ifdef LIBMESH_ENABLE_UNIQUE_ID
661#endif
662
671 virtual void reserve_elem (const dof_id_type ne) = 0;
672
677 virtual void update_parallel_id_counts () = 0;
678
684 virtual dof_id_type n_active_elem () const = 0;
685
690
695 { return this->n_elem_on_proc (this->processor_id()); }
696
702
707
712 { return this->n_active_elem_on_proc (this->processor_id()); }
713
723 dof_id_type n_sub_elem () const;
724
729
735 virtual const Point & point (const dof_id_type i) const = 0;
736
742 virtual const Node & node_ref (const dof_id_type i) const
743 {
744 return *this->node_ptr(i);
745 }
746
751 virtual Node & node_ref (const dof_id_type i)
752 {
753 return *this->node_ptr(i);
754 }
755
760 virtual const Node * node_ptr (const dof_id_type i) const = 0;
761
767 virtual Node * node_ptr (const dof_id_type i) = 0;
768
773 virtual const Node * query_node_ptr (const dof_id_type i) const = 0;
774
779 virtual Node * query_node_ptr (const dof_id_type i) = 0;
780
785 virtual const Elem & elem_ref (const dof_id_type i) const
786 {
787 return *this->elem_ptr(i);
788 }
789
795 virtual Elem & elem_ref (const dof_id_type i)
796 {
797 return *this->elem_ptr(i);
798 }
799
804 virtual const Elem * elem_ptr (const dof_id_type i) const = 0;
805
811 virtual Elem * elem_ptr (const dof_id_type i) = 0;
812
817 virtual const Elem * query_elem_ptr (const dof_id_type i) const = 0;
818
823 virtual Elem * query_elem_ptr (const dof_id_type i) = 0;
824
835 virtual Node * add_point (const Point & p,
837 const processor_id_type proc_id =
839
843 virtual Node * add_node (Node * n) = 0;
844
853 virtual Node * add_node (std::unique_ptr<Node> n) = 0;
854
858 virtual void delete_node (Node * n) = 0;
859
866 virtual void own_node (Node &) {}
867
873 virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) = 0;
874
884 virtual Elem * add_elem (Elem * e) = 0;
885
894 virtual Elem * add_elem (std::unique_ptr<Elem> e) = 0;
895
903 virtual Elem * insert_elem (Elem * e) = 0;
904
913 virtual Elem * insert_elem (std::unique_ptr<Elem> e) = 0;
914
925 virtual void delete_elem (Elem * e) = 0;
926
932 virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) = 0;
933
942
948 {
950 }
951
956 unsigned char default_mapping_data () const
957 {
959 }
960
965 void set_default_mapping_data (const unsigned char data)
966 {
968 }
969
993 virtual void find_neighbors (const bool reset_remote_elements = false,
994 const bool reset_current_list = true,
995 const bool assert_valid = true,
996 const bool check_non_remote = true) = 0;
997
1002 void remove_orphaned_nodes ();
1003
1009 virtual void renumber_nodes_and_elements () = 0;
1010
1018
1019
1020#ifdef LIBMESH_ENABLE_AMR
1026 virtual bool contract () = 0;
1027#endif
1028
1046 unsigned int add_elem_integer(std::string name,
1047 bool allocate_data = true,
1048 dof_id_type default_value = DofObject::invalid_id);
1049
1064 std::vector<unsigned int> add_elem_integers(const std::vector<std::string> & names,
1065 bool allocate_data = true,
1066 const std::vector<dof_id_type> * default_values = nullptr);
1067
1068 /*
1069 * \returns The index number for the named extra element integer
1070 * datum, which must have already been added.
1071 */
1072 unsigned int get_elem_integer_index(std::string_view name) const;
1073
1074 /*
1075 * \returns Whether or not the mesh has an element integer with its name.
1076 */
1077 bool has_elem_integer(std::string_view name) const;
1078
1079 /*
1080 * \returns The name for the indexed extra element integer
1081 * datum, which must have already been added.
1082 */
1083 const std::string & get_elem_integer_name(unsigned int i) const
1084 { return _elem_integer_names[i]; }
1085
1086 /*
1087 * \returns The number of extra element integers for which space is
1088 * being reserved on this mesh.
1089 *
1090 * If non-integer data has been associated, each datum of type T
1091 * counts for sizeof(T)/sizeof(dof_id_type) times in the return
1092 * value.
1093 */
1094 unsigned int n_elem_integers() const { return _elem_integer_names.size(); }
1095
1121 template <typename T>
1122 unsigned int add_elem_datum(const std::string & name,
1123 bool allocate_data = true,
1124 const T * default_value = nullptr);
1125
1146 template <typename T>
1147 std::vector<unsigned int> add_elem_data(const std::vector<std::string> & names,
1148 bool allocate_data = true,
1149 const std::vector<T> * default_values = nullptr);
1150
1168 unsigned int add_node_integer(std::string name,
1169 bool allocate_data = true,
1170 dof_id_type default_value = DofObject::invalid_id);
1171
1186 std::vector<unsigned int> add_node_integers(const std::vector<std::string> & names,
1187 bool allocate_data = true,
1188 const std::vector<dof_id_type> * default_values = nullptr);
1189
1190 /*
1191 * \returns The index number for the named extra node integer
1192 * datum, which must have already been added.
1193 */
1194 unsigned int get_node_integer_index(std::string_view name) const;
1195
1196 /*
1197 * \returns Whether or not the mesh has a node integer with its name.
1198 */
1199 bool has_node_integer(std::string_view name) const;
1200
1201 /*
1202 * \returns The name for the indexed extra node integer
1203 * datum, which must have already been added.
1204 */
1205 const std::string & get_node_integer_name(unsigned int i) const
1206 { return _node_integer_names[i]; }
1207
1208 /*
1209 * \returns The number of extra node integers for which space is
1210 * being reserved on this mesh.
1211 *
1212 * If non-integer data has been associated, each datum of type T
1213 * counts for sizeof(T)/sizeof(dof_id_type) times in the return
1214 * value.
1215 */
1216 unsigned int n_node_integers() const { return _node_integer_names.size(); }
1217
1243 template <typename T>
1244 unsigned int add_node_datum(const std::string & name,
1245 bool allocate_data = true,
1246 const T * default_value = nullptr);
1247
1268 template <typename T>
1269 std::vector<unsigned int> add_node_data(const std::vector<std::string> & name,
1270 bool allocate_data = true,
1271 const std::vector<T> * default_values = nullptr);
1272
1304#ifdef LIBMESH_ENABLE_DEPRECATED
1305 void prepare_for_use (const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors);
1306 void prepare_for_use (const bool skip_renumber_nodes_and_elements);
1307#endif // LIBMESH_ENABLE_DEPRECATED
1308 void prepare_for_use ();
1309
1310 /*
1311 * Prepare a newly created or modified mesh for use.
1312 *
1313 * Unlike \p prepare_for_use(), \p complete_preparation() performs
1314 * *only* those preparatory steps that have been marked as
1315 * necessary in the MeshBase::Preparation state.
1316 */
1317 void complete_preparation();
1318
1322 virtual void partition (const unsigned int n_parts);
1323
1325 { this->partition(this->n_processors()); }
1326
1333 virtual void redistribute ();
1334
1340 virtual void update_post_partitioning ();
1341
1361
1366 void allow_find_neighbors(bool allow) { _skip_find_neighbors = !allow; }
1368
1375
1384
1393
1417
1420
1421
1433 void skip_partitioning(bool skip) { _skip_all_partitioning = skip; }
1434
1436
1446 void add_ghosting_functor(GhostingFunctor & ghosting_functor);
1447
1456 void add_ghosting_functor(std::shared_ptr<GhostingFunctor> ghosting_functor)
1457 { _shared_functors[ghosting_functor.get()] = ghosting_functor;
1458 this->add_ghosting_functor(*ghosting_functor); }
1459
1464 void remove_ghosting_functor(GhostingFunctor & ghosting_functor);
1465
1471 typedef std::vector<GhostingFunctor *>::const_iterator GhostingFunctorIterator;
1472
1478
1484
1489
1502 void subdomain_ids (std::set<subdomain_id_type> & ids, const bool global = true) const;
1503
1512
1521
1530 unsigned int n_partitions () const
1531 { return _n_parts; }
1532
1549 std::string get_info (const unsigned int verbosity = 0, const bool global = true) const;
1550
1557 void print_info (std::ostream & os=libMesh::out, const unsigned int verbosity = 0, const bool global = true) const;
1558
1564 friend std::ostream & operator << (std::ostream & os, const MeshBase & m);
1565
1570 virtual void read (const std::string & name,
1571 void * mesh_data=nullptr,
1572 bool skip_renumber_nodes_and_elements=false,
1573 bool skip_find_neighbors=false,
1574 bool skip_detect_interior_parents=false) = 0;
1575 virtual void write (const std::string & name) const = 0;
1576
1583 virtual void all_first_order () = 0;
1584
1590
1598 struct element_iterator;
1600
1608 struct node_iterator;
1609 struct const_node_iterator;
1610
1623 const bool full_ordered = true) = 0;
1624
1629 void all_second_order (const bool full_ordered = true);
1630
1639
1644 virtual void all_complete_order ();
1645
1655 unsigned int recalculate_n_partitions();
1656
1664 std::unique_ptr<PointLocatorBase> sub_point_locator () const;
1665
1677
1681 void clear_point_locator ();
1682
1688 void set_count_lower_dim_elems_in_point_locator(bool count_lower_dim_elems);
1689
1694
1703
1704#ifdef LIBMESH_ENABLE_DEPRECATED
1711 std::string & subdomain_name(subdomain_id_type id);
1712#endif // LIBMESH_ENABLE_DEPRECATED
1713
1718 const std::string & subdomain_name(subdomain_id_type id) const;
1719
1728 const std::string & name,
1729 bool synchronous = false);
1730
1735 subdomain_id_type get_id_by_name(std::string_view name) const;
1736
1737 /*
1738 * We have many combinations of iterators that filter on various
1739 * characteristics; we use macros to make their abstract base class
1740 * and their subclass declarations more terse.
1741 */
1742#define ABSTRACT_ELEM_ITERATORS(TYPE, ARGDECL) \
1743 virtual element_iterator TYPE##elements_begin(ARGDECL) = 0; \
1744 virtual element_iterator TYPE##elements_end(ARGDECL) = 0; \
1745 virtual const_element_iterator TYPE##elements_begin(ARGDECL) const = 0; \
1746 virtual const_element_iterator TYPE##elements_end(ARGDECL) const = 0; \
1747 virtual SimpleRange<element_iterator> TYPE##element_ptr_range(ARGDECL) = 0; \
1748 virtual SimpleRange<const_element_iterator> TYPE##element_ptr_range(ARGDECL) const = 0;
1749
1750#define DECLARE_ELEM_ITERATORS(TYPE, ARGDECL, ARGS) \
1751 virtual element_iterator TYPE##elements_begin(ARGDECL) override final; \
1752 virtual element_iterator TYPE##elements_end(ARGDECL) override final; \
1753 virtual const_element_iterator TYPE##elements_begin(ARGDECL) const override final; \
1754 virtual const_element_iterator TYPE##elements_end(ARGDECL) const override final; \
1755 virtual SimpleRange<element_iterator> TYPE##element_ptr_range(ARGDECL) override final { return {TYPE##elements_begin(ARGS), TYPE##elements_end(ARGS)}; } \
1756 virtual SimpleRange<const_element_iterator> TYPE##element_ptr_range(ARGDECL) const override final { return {TYPE##elements_begin(ARGS), TYPE##elements_end(ARGS)}; }
1757
1758#define ABSTRACT_NODE_ITERATORS(TYPE, ARGDECL) \
1759 virtual node_iterator TYPE##nodes_begin(ARGDECL) = 0; \
1760 virtual node_iterator TYPE##nodes_end(ARGDECL) = 0; \
1761 virtual const_node_iterator TYPE##nodes_begin(ARGDECL) const = 0; \
1762 virtual const_node_iterator TYPE##nodes_end(ARGDECL) const = 0; \
1763 virtual SimpleRange<node_iterator> TYPE##node_ptr_range(ARGDECL) = 0; \
1764 virtual SimpleRange<const_node_iterator> TYPE##node_ptr_range(ARGDECL) const = 0;
1765
1766#define DECLARE_NODE_ITERATORS(TYPE, ARGDECL, ARGS) \
1767 virtual node_iterator TYPE##nodes_begin(ARGDECL) override final; \
1768 virtual node_iterator TYPE##nodes_end(ARGDECL) override final; \
1769 virtual const_node_iterator TYPE##nodes_begin(ARGDECL) const override final; \
1770 virtual const_node_iterator TYPE##nodes_end(ARGDECL) const override final; \
1771 virtual SimpleRange<node_iterator> TYPE##node_ptr_range(ARGDECL) override final { return {TYPE##nodes_begin(ARGS), TYPE##nodes_end(ARGS)}; } \
1772 virtual SimpleRange<const_node_iterator> TYPE##node_ptr_range(ARGDECL) const override final { return {TYPE##nodes_begin(ARGS), TYPE##nodes_end(ARGS)}; }
1773
1774#define LIBMESH_COMMA ,
1775
1776 /*
1777 * element_iterator accessors
1778 *
1779 * The basic elements_begin() and elements_end() iterators iterate
1780 * over all elements in a mesh, returning element pointers or const
1781 * element pointers when dereferenced (depending on whether the mesh
1782 * reference was const). range-for loops can be written using
1783 * element_ptr_range()
1784 *
1785 * Filtered versions of these iterators, which skip over all
1786 * elements not matching some predicate, are also available, by
1787 * adding a prefix to the methods above. E.g. local_ (in a form
1788 * like local_elements_begin() or local_element_ptr_range()) will
1789 * iterate only over elements whose processor_id() is the current
1790 * processor, or active_ will iterate only over active elements even
1791 * if the mesh is refined, or active_local_ will iterate over
1792 * elements that are both active and local. Negation forms such as
1793 * not_local_ also exist.
1794 *
1795 * For some iterator prefixes, such as type_, an argument is needed
1796 * for the filter; e.g. the ElemType to select for in that case.
1797 *
1798 * All valid prefixes and their corresponding arguments can be found
1799 * in the macro invocations below.
1800 */
1801 ABSTRACT_ELEM_ITERATORS(,) // elements_begin(), element_ptr_range(): all elements
1802 ABSTRACT_ELEM_ITERATORS(active_,) // Elem::active() == true
1803 ABSTRACT_ELEM_ITERATORS(ancestor_,) // Elem::ancestor() == true
1804 ABSTRACT_ELEM_ITERATORS(subactive_,) // Elem::subactive() == true
1805 ABSTRACT_ELEM_ITERATORS(local_,) // Elem::processor_id() == this processor
1806 ABSTRACT_ELEM_ITERATORS(unpartitioned_,) // Elem::processor_id() == invalid_processor_id
1807 ABSTRACT_ELEM_ITERATORS(facelocal_,) // is on or has a neighbor on this processor
1808 ABSTRACT_ELEM_ITERATORS(level_,unsigned int level) // Elem::level() == level
1809 ABSTRACT_ELEM_ITERATORS(pid_,processor_id_type pid) // Elem::processor_id() == pid
1810 ABSTRACT_ELEM_ITERATORS(type_,ElemType type) // Elem::type() == type
1811
1812 ABSTRACT_ELEM_ITERATORS(active_subdomain_,subdomain_id_type sid) // active && Elem::subdomain_id() == sid
1813 ABSTRACT_ELEM_ITERATORS(active_subdomain_set_,std::set<subdomain_id_type> ss) // active && ss.contains(Elem::subdomain_id())
1814
1815 // Iterators which use negations of filters described above
1817 ABSTRACT_ELEM_ITERATORS(not_ancestor_,)
1819 ABSTRACT_ELEM_ITERATORS(not_local_,)
1820 ABSTRACT_ELEM_ITERATORS(not_level_,unsigned int level)
1821
1822 // Iterators which combine multiple of the filters described above
1823 ABSTRACT_ELEM_ITERATORS(active_local_,)
1824 ABSTRACT_ELEM_ITERATORS(active_not_local_,)
1825 ABSTRACT_ELEM_ITERATORS(active_unpartitioned_,)
1828 ABSTRACT_ELEM_ITERATORS(local_level_,unsigned int level)
1829 ABSTRACT_ELEM_ITERATORS(local_not_level_,unsigned int level)
1830 ABSTRACT_ELEM_ITERATORS(active_local_subdomain_,subdomain_id_type sid)
1831 ABSTRACT_ELEM_ITERATORS(active_local_subdomain_set_,std::set<subdomain_id_type> ss)
1832
1833 // Backwards compatibility
1840
1841 // Discouraged from use - these iterators use outdated
1842 // pre-GhostingFunctor definitions and should be renamed if not
1843 // deprecated
1844 ABSTRACT_ELEM_ITERATORS(semilocal_,) // active && Elem::is_semilocal()
1845 ABSTRACT_ELEM_ITERATORS(ghost_,) // active && Elem::is_semilocal() && not local discouraged
1846 ABSTRACT_ELEM_ITERATORS(active_semilocal_,)
1847
1848 // solution can be evaluated, with the given DoF map, for the given
1849 // variable number, or for all variables by default
1850 ABSTRACT_ELEM_ITERATORS(evaluable_,const DofMap & dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint)
1851
1852 // solution can be evaluated for all variables of all given DoF maps
1853 ABSTRACT_ELEM_ITERATORS(multi_evaluable_,std::vector<const DofMap *> dof_maps)
1854
1855#ifdef LIBMESH_ENABLE_AMR
1856 ABSTRACT_ELEM_ITERATORS(flagged_,unsigned char rflag) // Elem::refinement_flag() == rflag
1857
1858 // Elem::refinement_flag() == rflag && Elem::processor_id() == pid
1859 ABSTRACT_ELEM_ITERATORS(flagged_pid_,unsigned char rflag LIBMESH_COMMA processor_id_type pid)
1860#endif
1861
1862 /*
1863 * node_iterator accessors
1864 *
1865 * The basic nodes_begin() and nodes_end() iterators iterate
1866 * over all nodes in a mesh, returning node pointers or const
1867 * node pointers when dereferenced (depending on whether the mesh
1868 * reference was const). range-for loops can be written using
1869 * node_ptr_range()
1870 *
1871 * Filtered versions of these iterators, which skip over all
1872 * nodes not matching some predicate, are also available, by
1873 * adding a prefix to the methods above. E.g. local_ (in a form
1874 * like local_nodes_begin() or local_node_ptr_range()) will
1875 * iterate only over nodes whose processor_id() is the current
1876 * processor.
1877 *
1878 * All valid prefixes and their corresponding arguments can be found
1879 * in the macro invocations below.
1880 */
1881 ABSTRACT_NODE_ITERATORS(,) // nodes_begin(), node_ptr_range(): all nodes
1882 ABSTRACT_NODE_ITERATORS(active_,) // Node::active() == true; i.e. Node::id() != invalid_id
1883 ABSTRACT_NODE_ITERATORS(local_,) // Node::processor_id() == this processor
1884 ABSTRACT_NODE_ITERATORS(bnd_,) // BoundaryInfo::n_boundary_ids(node) > 0
1885 ABSTRACT_NODE_ITERATORS(pid_,processor_id_type pid) // Node::processor_id() == pid
1886 ABSTRACT_NODE_ITERATORS(bid_,boundary_id_type bid) // BoundaryInfo::has_boundary_id(node, bid)
1887
1888 // solution can be evaluated, with the given DoF map, for the given
1889 // variable number, or for all variables by default
1890 ABSTRACT_NODE_ITERATORS(evaluable_,const DofMap & dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint)
1891
1892 // solution can be evaluated for all variables of all given DoF maps
1893 ABSTRACT_NODE_ITERATORS(multi_evaluable_,std::vector<const DofMap *> dof_maps)
1894
1895 // Technically these define libMesh::MeshBase::*ElemRange, but since
1896 // those don't conflict with libMesh::*ElemRange they're as good as
1897 // a real forward declaration, which we can't do here.
1900
1909
1918
1923 void clear_stored_ranges();
1924
1930 const std::map<subdomain_id_type, std::string> & get_subdomain_name_map () const
1931 { return _block_id_to_name; }
1932
1933 typedef std::vector<std::pair<std::pair<const Elem *, unsigned int>, Real>> constraint_rows_mapped_type;
1934 typedef std::map<const Node *, constraint_rows_mapped_type> constraint_rows_type;
1935
1939#ifdef LIBMESH_ENABLE_DEPRECATED
1941 { libmesh_deprecated(); return _constraint_rows; }
1942#endif
1943
1946
1949
1955
1959 void copy_constraint_rows(const MeshBase & other_mesh);
1960
1988 template <typename T>
1989 void copy_constraint_rows(const SparseMatrix<T> & constraint_operator,
1990 bool precondition_constraint_operator = false);
1991
1998 void print_constraint_rows(std::ostream & os=libMesh::out,
1999 bool print_nonlocal=false) const;
2000
2006 std::string get_local_constraints(bool print_nonlocal=false) const;
2007
2008#ifdef LIBMESH_ENABLE_DEPRECATED
2016 void cache_elem_dims();
2017#endif // LIBMESH_ENABLE_DEPRECATED
2018
2019 /*
2020 * Search the mesh and cache data for the elements
2021 * present in the mesh. This is done in prepare_for_use(), but can
2022 * be done manually by other classes after major mesh modifications.
2023 * Data cached includes:
2024 * - elem dimensions
2025 * - elem subdomains
2026 */
2027 void cache_elem_data();
2028
2039
2045
2053 const MeshBase & interior_mesh() const { return *_interior_mesh; }
2054
2059
2063 void set_interior_mesh(MeshBase & int_mesh) { _interior_mesh = &int_mesh; }
2064
2070 const std::set<subdomain_id_type> & get_mesh_subdomains() const;
2071
2072#ifdef LIBMESH_ENABLE_PERIODIC
2077 const boundary_id_type b2,
2078 const RealVectorValue & translation);
2079
2081
2083
2085 const boundary_id_type b2);
2086#endif
2087
2092 {
2096 Preparation();
2097
2101 explicit operator bool() const;
2102
2106 Preparation & operator= (bool set_all);
2107
2112 bool operator== (const Preparation & other) const;
2113 bool operator!= (const Preparation & other) const;
2114
2125 };
2126
2127protected:
2128
2129#ifdef LIBMESH_ENABLE_PERIODIC
2131 std::unique_ptr<PeriodicBoundaries> _disjoint_neighbor_boundary_pairs;
2132#endif
2133
2143 std::unique_ptr<BoundaryInfo> boundary_info;
2144
2153 void post_dofobject_moves(MeshBase && other_mesh);
2154
2159 void copy_cached_data (const MeshBase & other_mesh);
2160
2165 virtual bool subclass_locally_equals (const MeshBase & other_mesh) const = 0;
2166
2171 bool nodes_and_elements_equal(const MeshBase & other_mesh) const;
2172
2176 unsigned int & set_n_partitions ()
2177 { return _n_parts; }
2178
2189 unsigned int _n_parts;
2190
2196
2203
2208
2217 mutable std::unique_ptr<ElemRange> _element_stored_range;
2218
2227 mutable std::unique_ptr<ConstElemRange>
2229
2237 mutable std::unique_ptr<PointLocatorBase> _point_locator;
2238
2244
2251 std::unique_ptr<Partitioner> _partitioner;
2252
2253#ifdef LIBMESH_ENABLE_UNIQUE_ID
2258#endif
2259
2265
2271
2276
2283
2288
2293
2301
2314
2320 std::map<subdomain_id_type, std::string> _block_id_to_name;
2321
2327 std::set<unsigned char> _elem_dims;
2328
2334 std::set<Order> _elem_default_orders;
2335
2341
2345 std::set<subdomain_id_type> _mesh_subdomains;
2346
2369 std::map<dof_id_type, const MeshBase::elemset_type *> _elemset_codes;
2370 std::map<MeshBase::elemset_type, dof_id_type> _elemset_codes_inverse_map;
2372
2377 unsigned char _spatial_dimension;
2378
2383 std::vector<std::string> _elem_integer_names;
2384
2389 std::vector<dof_id_type> _elem_integer_default_values;
2390
2395 std::vector<std::string> _node_integer_names;
2396
2401 std::vector<dof_id_type> _node_integer_default_values;
2402
2407
2412
2419 std::pair<std::vector<unsigned int>, std::vector<unsigned int>>
2420 merge_extra_integer_names(const MeshBase & other);
2421
2427 std::unique_ptr<GhostingFunctor> _default_ghosting;
2428
2436 std::vector<GhostingFunctor *> _ghosting_functors;
2437
2442 std::map<GhostingFunctor *, std::shared_ptr<GhostingFunctor> > _shared_functors;
2443
2444 // Keep track of any constraint equations that are inherent to the
2445 // mesh, such as FE nodes whose Rational Bernstein values need to be
2446 // constrained in terms of values on spline control nodes.
2447 //
2448 // _constraint_rows[constrained_node][i].first.first is an
2449 // element (e.g. a NodeElem for a spline control node),
2450 // _constraint_rows[constrained_node][i].first.second is the
2451 // local node id of that element which is a constraining node,
2452 // _constraint_rows[constrained_node][i].second is that node's
2453 // constraint coefficient.
2455
2457
2462
2468
2473 friend class Partitioner;
2474
2479 friend class MeshInput<MeshBase>;
2480
2485 friend class BoundaryInfo;
2486
2491 friend class MeshCommunication;
2492
2493
2498#ifdef LIBMESH_ENABLE_DEPRECATED
2500
2502 Elem * const,
2503 Elem * const &,
2505
2507
2509 Node * const,
2510 Node * const &,
2512#else
2514 Elem * const,
2515 Elem * const &,
2516 Elem * const *,
2517 const Elem * const,
2518 const Elem * const &,
2519 const Elem * const *> elem_filter_iter;
2520
2522 const Elem * const,
2523 const Elem * const &,
2525
2527 Node * const,
2528 Node * const &,
2529 Node * const *,
2530 const Node * const,
2531 const Node * const &,
2532 const Node * const *> node_filter_iter;
2533
2535 const Node * const,
2536 const Node * const &,
2538#endif // LIBMESH_ENABLE_DEPRECATED
2539
2540};
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2555struct
2557{
2558 // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
2559 template <typename PredType, typename IterType>
2560 element_iterator (const IterType & d,
2561 const IterType & e,
2562 const PredType & p ) :
2563 elem_filter_iter(d,e,p) {}
2564};
2565
2566
2567
2568
2573struct
2575{
2579 template <typename PredType, typename IterType>
2580 const_element_iterator (const IterType & d,
2581 const IterType & e,
2582 const PredType & p ) :
2583 const_elem_filter_iter(d,e,p) {}
2584
2593};
2594
2595
2596
2597
2598
2599
2600
2604struct
2606{
2610 template <typename PredType, typename IterType>
2611 node_iterator (const IterType & d,
2612 const IterType & e,
2613 const PredType & p ) :
2614 node_filter_iter(d,e,p) {}
2615};
2616
2617
2618
2619
2624struct
2626{
2630 template <typename PredType, typename IterType>
2631 const_node_iterator (const IterType & d,
2632 const IterType & e,
2633 const PredType & p ) :
2634 const_node_filter_iter(d,e,p) {}
2635
2644};
2645
2646
2647// ------------------------------------------------------------
2648// Elem class member functions
2649inline
2650const std::set<unsigned char> & MeshBase::elem_dimensions() const
2651{
2653 return _elem_dims;
2654}
2655
2656
2657inline
2658const std::set<Order> & MeshBase::elem_default_orders() const
2659{
2661 return _elem_default_orders;
2662}
2663
2664
2665inline
2671
2672
2673inline
2674const std::set<subdomain_id_type> & MeshBase::get_mesh_subdomains() const
2675{
2677 return _mesh_subdomains;
2678}
2679
2680
2681inline
2682unsigned int MeshBase::spatial_dimension () const
2683{
2685
2686 return cast_int<unsigned int>(_spatial_dimension);
2687}
2688
2689
2690inline
2697
2698
2699template <typename T>
2700inline
2701unsigned int MeshBase::add_elem_datum(const std::string & name,
2702 bool allocate_data,
2703 const T * default_value)
2704{
2705 const std::size_t old_size = _elem_integer_names.size();
2706
2707 unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
2708 std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
2709 if (default_value)
2710 std::memcpy(int_data.data(), default_value, sizeof(T));
2711
2712 unsigned int start_idx = this->add_elem_integer(name, false, int_data[0]);
2713 for (unsigned int i=0; i != n_more_integers; ++i)
2714 this->add_elem_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
2715
2716 if (allocate_data && old_size != _elem_integer_names.size())
2718
2719 return start_idx;
2720}
2721
2722
2723template <typename T>
2724inline
2725std::vector<unsigned int> MeshBase::add_elem_data(const std::vector<std::string> & names,
2726 bool allocate_data,
2727 const std::vector<T> * default_values)
2728{
2729 libmesh_assert(!default_values || default_values->size() == names.size());
2730
2731 std::vector<unsigned int> returnval(names.size());
2732
2733 const std::size_t old_size = _elem_integer_names.size();
2734
2735 for (auto i : index_range(names))
2736 returnval[i] =
2737 this->add_elem_datum<T>(names[i], false,
2738 default_values ?
2739 (*default_values)[i] : nullptr);
2740
2741 if (allocate_data && old_size != _elem_integer_names.size())
2743
2744 return returnval;
2745}
2746
2747
2748template <typename T>
2749inline
2750unsigned int MeshBase::add_node_datum(const std::string & name,
2751 bool allocate_data,
2752 const T * default_value)
2753{
2754 const std::size_t old_size = _node_integer_names.size();
2755
2756 unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
2757 std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
2758 if (default_value)
2759 std::memcpy(int_data.data(), default_value, sizeof(T));
2760
2761 unsigned int start_idx = this->add_node_integer(name, false, int_data[0]);
2762 for (unsigned int i=0; i != n_more_integers; ++i)
2763 this->add_node_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
2764
2765 if (allocate_data && old_size != _node_integer_names.size())
2767
2768 return start_idx;
2769}
2770
2771
2772template <typename T>
2773inline
2774std::vector<unsigned int> MeshBase::add_node_data(const std::vector<std::string> & names,
2775 bool allocate_data,
2776 const std::vector<T> * default_values)
2777{
2778 libmesh_assert(!default_values || default_values->size() == names.size());
2779
2780 std::vector<unsigned int> returnval(names.size());
2781
2782 const std::size_t old_size = _node_integer_names.size();
2783
2784 for (auto i : index_range(names))
2785 returnval[i] =
2786 this->add_node_datum<T>(names[i], false,
2787 default_values ?
2788 (*default_values)[i] : nullptr);
2789
2790 if (allocate_data && old_size != _node_integer_names.size())
2792
2793 return returnval;
2794}
2795
2796
2797
2798} // namespace libMesh
2799
2800#endif // LIBMESH_MESH_BASE_H
unsigned int dim
void ErrorVector unsigned int
The BoundaryInfo class contains information relevant to boundary conditions including storing faces,...
This class handles the numbering of degrees of freedom on a mesh.
Definition dof_map.h:181
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition dof_object.h:473
static constexpr 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:484
This is the base class from which all geometric element types are derived.
Definition elem.h:96
This abstract base class defines the interface by which library code and user code can report associa...
This is the MeshBase class.
Definition mesh_base.h:81
void set_subdomain_name(subdomain_id_type id, const std::string &name, bool synchronous=false)
Sets the name for the provided id.
Definition mesh_base.C:1929
void allow_remote_element_removal(bool allow)
If false is passed in then this mesh will no longer have remote elements deleted when being prepared ...
Definition mesh_base.h:1382
void set_isnt_prepared()
Tells this we have done some operation where we should no longer consider ourself prepared.
Definition mesh_base.h:228
variant_filter_iterator< MeshBase::Predicate, Elem *const, Elem *const &, Elem *const *, const Elem *const, const Elem *const &, const Elem *const * > elem_filter_iter
Definition mesh_base.h:2519
virtual const Node & node_ref(const dof_id_type i) const
Definition mesh_base.h:742
virtual const Point & point(const dof_id_type i) const =0
void unset_has_reinit_ghosting_functors()
Tells this we have done some operation (e.g.
Definition mesh_base.h:330
virtual bool is_serial() const
Definition mesh_base.h:357
void size_elem_extra_integers()
Size extra-integer arrays of all elements in the mesh.
Definition mesh_base.C:2376
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 elem...
Definition mesh_base.h:965
virtual dof_id_type parallel_n_elem() const =0
virtual bool contract()=0
Delete subactive (i.e.
unsigned int n_elem_integers() const
Definition mesh_base.h:1094
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition mesh_base.h:170
void set_spatial_dimension(unsigned char d)
Sets the "spatial dimension" of the Mesh.
Definition mesh_base.C:613
virtual Elem & elem_ref(const dof_id_type i)
Definition mesh_base.h:795
Preparation preparation() const
Definition mesh_base.h:213
bool is_prepared() const
Definition mesh_base.C:1065
virtual std::unique_ptr< Partitioner > & partitioner()
A partitioner to use at each partitioning.
Definition mesh_base.h:165
bool allow_renumbering() const
Definition mesh_base.h:1360
virtual const Node * node_ptr(const dof_id_type i) const =0
MeshBase::elemset_type _all_elemset_ids
Definition mesh_base.h:2371
unsigned int mesh_dimension() const
Definition mesh_base.C:435
bool _allow_node_and_elem_unique_id_overlap
The Exodus reader (and potentially other readers in the future?) now supports setting Node and Elem u...
Definition mesh_base.h:2313
variant_filter_iterator< MeshBase::Predicate, const Node *const, const Node *const &, const Node *const * > const_node_filter_iter
Definition mesh_base.h:2537
virtual Node * query_node_ptr(const dof_id_type i)=0
virtual dof_id_type n_elem() const =0
virtual void all_first_order()=0
Converts a mesh with higher-order elements into a mesh with linear elements.
virtual bool is_replicated() const
Definition mesh_base.h:379
std::vector< unsigned int > add_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.
Definition mesh_base.h:2774
void complete_preparation()
Definition mesh_base.C:874
bool _skip_detect_interior_parents
If this is true then we will skip detect_interior_parents in prepare_for_use.
Definition mesh_base.h:2292
bool operator==(const MeshBase &other_mesh) const
This tests for exactly-equal data in all the senses that a mathematician would care about (element co...
Definition mesh_base.C:274
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 automaticall...
Definition mesh_base.C:444
virtual void own_node(Node &)
Takes ownership of node n on this partition of a distributed mesh, by setting n.processor_id() to thi...
Definition mesh_base.h:866
virtual Elem * insert_elem(Elem *e)=0
Insert elem e to the element array, preserving its id and replacing/deleting any existing element wit...
const std::set< unsigned char > & elem_dimensions() const
Definition mesh_base.h:2650
void print_constraint_rows(std::ostream &os=libMesh::out, bool print_nonlocal=false) const
Prints (from processor 0) all mesh constraint rows.
Definition mesh_base.C:2803
bool skip_partitioning() const
Definition mesh_base.h:1435
Order supported_nodal_order() const
Definition mesh_base.h:2666
Order _supported_nodal_order
We cache the maximum nodal order supported by all the mesh's elements (the minimum supported_nodal_or...
Definition mesh_base.h:2340
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 t...
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,...
Definition mesh_base.C:1127
virtual Node * node_ptr(const dof_id_type i)=0
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:1828
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...
void set_point_locator_close_to_point_tol(Real val)
Set value used by PointLocatorBase::close_to_point_tol().
Definition mesh_base.C:2355
dof_id_type n_active_elem_on_proc(const processor_id_type proc) const
Definition mesh_base.C:1243
bool has_node_integer(std::string_view name) const
Definition mesh_base.C:790
virtual SimpleRange< element_iterator > active_subdomain_set_elements_ptr_range(std::set< subdomain_id_type > ss)=0
bool allow_detect_interior_parents() const
Definition mesh_base.h:1374
void allow_find_neighbors(bool allow)
If false is passed then this mesh will no longer work to find element neighbors when being prepared f...
Definition mesh_base.h:1366
unsigned int spatial_dimension() const
Definition mesh_base.h:2682
PeriodicBoundaries * get_disjoint_neighbor_boundary_pairs()
Definition mesh_base.C:2311
void change_elemset_id(elemset_id_type old_id, elemset_id_type new_id)
Replace elemset id "old_id" with "new_id".
Definition mesh_base.C:570
unsigned int get_elem_integer_index(std::string_view name) const
Definition mesh_base.C:689
void allow_renumbering(bool allow)
If false is passed in then this mesh will no longer be renumbered when being prepared for use.
Definition mesh_base.h:1359
const std::map< subdomain_id_type, std::string > & get_subdomain_name_map() const
Definition mesh_base.h:1930
subdomain_id_type n_local_subdomains() const
Definition mesh_base.C:1205
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.
Definition mesh_base.C:1818
virtual void delete_node(Node *n)=0
Removes the Node n from the mesh.
unsigned int get_node_integer_index(std::string_view name) const
Definition mesh_base.C:778
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:2369
bool allow_node_and_elem_unique_id_overlap() const
Definition mesh_base.h:1392
dof_id_type get_elemset_code(const MeshBase::elemset_type &id_set) const
Definition mesh_base.C:502
void unset_has_neighbor_ptrs()
Tells this we have done some operation (e.g.
Definition mesh_base.h:270
dof_id_type n_sub_elem() const
Definition mesh_base.C:1252
const ConstElemRange & active_local_element_stored_range() const
Definition mesh_base.C:1969
virtual void redistribute()
Redistribute elements between processors.
Definition mesh_base.C:1169
const ElemRange & element_stored_range()
Definition mesh_base.C:1954
const DofMap &dof_map LIBMESH_COMMA unsigned int var_num
Definition mesh_base.h:1850
std::unique_ptr< PeriodicBoundaries > _disjoint_neighbor_boundary_pairs
The disjoint neighbor boundary id pairs.
Definition mesh_base.h:2131
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:735
unsigned char _spatial_dimension
The "spatial dimension" of the Mesh.
Definition mesh_base.h:2377
virtual ~MeshBase()
Destructor.
Definition mesh_base.C:426
std::map< MeshBase::elemset_type, dof_id_type > _elemset_codes_inverse_map
Definition mesh_base.h:2370
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:2243
virtual void write(const std::string &name) const =0
dof_id_type n_active_sub_elem() const
Same as n_sub_elem(), but only counts active elements.
Definition mesh_base.C:1264
virtual SimpleRange< element_iterator > active_local_subdomain_elements_ptr_range(subdomain_id_type sid)=0
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:2300
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:712
void change_elemset_code(dof_id_type old_code, dof_id_type new_code)
Replace elemset code "old_code" with "new_code".
Definition mesh_base.C:517
void unset_has_boundary_id_sets()
Tells this we have done some operation which may have invalidated our cached boundary id sets.
Definition mesh_base.h:340
virtual std::unique_ptr< MeshBase > clone() const =0
Virtual "copy constructor".
const std::string & get_node_integer_name(unsigned int i) const
Definition mesh_base.h:1205
std::vector< dof_id_type > get_elemset_codes() const
Return a vector of all elemset codes defined on the mesh.
Definition mesh_base.C:508
virtual dof_id_type n_nodes() const =0
virtual void delete_elem(Elem *e)=0
Removes element e from the mesh.
ElemMappingType default_mapping_type() const
Returns the default master space to physical space mapping basis functions to be used on newly added ...
Definition mesh_base.h:938
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:2401
virtual void read(const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false, bool skip_detect_interior_parents=false)=0
Interfaces for reading/writing a mesh to/from a file.
unique_id_type _next_unique_id
The next available unique id for assigning ids to DOF objects.
Definition mesh_base.h:2257
bool _skip_renumber_nodes_and_elements
If this is true then renumbering will be kept to a minimum.
Definition mesh_base.h:2282
virtual dof_id_type max_node_id() const =0
void remove_ghosting_functor(GhostingFunctor &ghosting_functor)
Removes a functor which was previously added to the set of ghosting functors.
Definition mesh_base.C:1101
virtual const Node * query_node_ptr(const dof_id_type i) const =0
std::vector< std::pair< std::pair< const Elem *, unsigned int >, Real > > constraint_rows_mapped_type
Definition mesh_base.h:1933
void set_mesh_dimension(unsigned char d)
Resets the logical dimension of the mesh.
Definition mesh_base.h:423
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.
GhostingFunctorIterator ghosting_functors_begin() const
Beginning of range of ghosting functors.
Definition mesh_base.h:1476
void unset_has_synched_subdomain_name_map()
Tells this we have done some operation which may have left the subdomain id to name map inconsistent ...
Definition mesh_base.h:350
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:2442
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.
std::set< subdomain_id_type > _mesh_subdomains
We cache the subdomain ids of the elements present in the mesh.
Definition mesh_base.h:2345
dof_id_type n_unpartitioned_elem() const
Definition mesh_base.h:700
virtual void update_post_partitioning()
Recalculate any cached data (or invalidate any caches that are computed on the fly) after elements an...
Definition mesh_base.C:1181
bool get_count_lower_dim_elems_in_point_locator() const
Get the current value of _count_lower_dim_elems_in_point_locator.
Definition mesh_base.C:1895
std::unique_ptr< PointLocatorBase > _point_locator
A PointLocator class for this mesh.
Definition mesh_base.h:2237
virtual const Elem * elem_ptr(const dof_id_type i) const =0
std::vector< unsigned int > add_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.
Definition mesh_base.h:2725
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 ...
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:623
bool _skip_all_partitioning
If this is true then no partitioning should be done.
Definition mesh_base.h:2275
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,...
ABSTRACT_ELEM_ITERATORS(,) ABSTRACT_ELEM_ITERATORS(active_
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:2383
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 > active_subdomain_elements_ptr_range(subdomain_id_type sid)=0
void prepare_for_use()
Definition mesh_base.C:860
void unset_has_synched_id_counts()
Tells this we have done some operation (e.g.
Definition mesh_base.h:257
void unset_has_removed_orphaned_nodes()
Tells this we have done some operation (e.g.
Definition mesh_base.h:318
variant_filter_iterator< MeshBase::Predicate, Node *const, Node *const &, Node *const *, const Node *const, const Node *const &, const Node *const * > node_filter_iter
Definition mesh_base.h:2532
const constraint_rows_type & get_constraint_rows() const
Definition mesh_base.h:1944
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:2389
void unset_is_partitioned()
Tells this we have done some operation creating unpartitioned elements.
Definition mesh_base.h:246
void remove_orphaned_nodes()
Removes any orphaned nodes, nodes not connected to any elements.
Definition mesh_base.C:801
Real get_point_locator_close_to_point_tol() const
Definition mesh_base.C:2369
variant_filter_iterator< MeshBase::Predicate, const Elem *const, const Elem *const &, const Elem *const * > const_elem_filter_iter
Definition mesh_base.h:2524
unsigned int n_partitions() const
Definition mesh_base.h:1530
virtual void set_next_unique_id(unique_id_type id)=0
Sets the next available unique id to be used.
virtual Node * add_node(Node *n)=0
Add Node n to the end of the vertex array.
bool has_elem_integer(std::string_view name) const
Definition mesh_base.C:701
virtual Node * add_node(std::unique_ptr< Node > n)=0
Version of add_node() taking a std::unique_ptr by value.
dof_id_type n_local_elem() const
Definition mesh_base.h:694
dof_id_type n_unpartitioned_nodes() const
Definition mesh_base.h:594
virtual dof_id_type max_elem_id() const =0
void unset_has_interior_parent_ptrs()
Tells this we have done some operation (e.g.
Definition mesh_base.h:293
const std::string & get_elem_integer_name(unsigned int i) const
Definition mesh_base.h:1083
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:2270
virtual void allgather()
Gathers all elements and nodes of the mesh onto every processor.
Definition mesh_base.h:386
bool _skip_find_neighbors
If this is true then we will skip find_neighbors in prepare_for_use.
Definition mesh_base.h:2287
void unset_has_cached_elem_data()
Tells this we have done some operation (e.g.
Definition mesh_base.h:281
dof_id_type n_elem_on_proc(const processor_id_type proc) const
Definition mesh_base.C:1230
virtual Elem * insert_elem(std::unique_ptr< Elem > e)=0
Version of insert_elem() taking a std::unique_ptr by value.
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:399
MeshBase & operator=(const MeshBase &)=delete
Copy and move assignment are not allowed because MeshBase subclasses manually manage memory (Elems an...
ElemMappingType _default_mapping_type
The default mapping type (typically Lagrange) between master and physical space to assign to newly ad...
Definition mesh_base.h:2195
std::unique_ptr< BoundaryInfo > boundary_info
This class holds the boundary information.
Definition mesh_base.h:2143
std::set< Order > _elem_default_orders
We cache the (default) order of the geometric elements present in the mesh.
Definition mesh_base.h:2334
virtual void clear_elems()=0
Deletes all the element data that is currently stored.
const std::set< subdomain_id_type > & get_mesh_subdomains() const
Definition mesh_base.h:2674
bool skip_noncritical_partitioning() const
Definition mesh_base.h:1418
MeshBase * _interior_mesh
Defaulting to this, a pointer to the mesh used to generate boundary elements on this.
Definition mesh_base.h:2264
variant_filter_iterator< MeshBase::Predicate, Elem *const, Elem *const &, Elem *const * > const_elem_filter_iter
Definition mesh_base.h:2504
virtual void set_distributed()
Asserts that not all elements and nodes of the mesh necessarily exist on the current processor.
Definition mesh_base.h:372
std::vector< GhostingFunctor * > _ghosting_functors
The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.
Definition mesh_base.h:2436
virtual void clear()
Deletes all the element and node data that is currently stored.
Definition mesh_base.C:1036
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > merge_extra_integer_names(const MeshBase &other)
Merge extra-integer arrays from an other mesh.
Definition mesh_base.C:2400
dof_id_type n_local_nodes() const
Definition mesh_base.h:588
std::unique_ptr< ConstElemRange > _const_active_local_element_stored_range
A cached ConstElemRange for threaded calculation on all local elements of this mesh.
Definition mesh_base.h:2228
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:2320
constraint_rows_type & set_constraint_rows()
Definition mesh_base.h:1947
const std::set< Order > & elem_default_orders() const
Definition mesh_base.h:2658
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 elem...
Definition mesh_base.h:947
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.
constraint_rows_type _constraint_rows
Definition mesh_base.h:2454
virtual Elem * add_elem(std::unique_ptr< Elem > e)=0
Version of add_elem() taking a std::unique_ptr by value.
std::unique_ptr< Partitioner > _partitioner
A partitioner to use at each prepare_for_use().
Definition mesh_base.h:2251
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.
Definition mesh_base.h:2750
unsigned int n_elemsets() const
Returns the number of unique elemset ids which have been added via add_elemset_code(),...
Definition mesh_base.C:487
constraint_rows_type & get_constraint_rows()
Constraint rows accessors.
Definition mesh_base.h:1940
GhostingFunctor & default_ghosting()
Default ghosting functor.
Definition mesh_base.h:1488
const MeshBase & interior_mesh() const
Definition mesh_base.h:2053
friend 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 << s...
Definition mesh_base.C:1777
std::unique_ptr< GhostingFunctor > _default_ghosting
The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior.
Definition mesh_base.h:2427
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:461
void unset_has_removed_remote_elements()
Tells this we have done some operation (e.g.
Definition mesh_base.h:307
unsigned int n_node_integers() const
Definition mesh_base.h:1216
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:2202
virtual void fix_broken_node_and_element_numbering()=0
There is no reason for a user to ever call this function.
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0
dof_id_type n_constraint_rows() const
Returns how many total constraint rows we have.
Definition mesh_base.h:2691
virtual void all_complete_order()
Calls the range-based version of this function with a range consisting of all elements in the mesh.
Definition mesh_base.C:1823
virtual Elem * add_elem(Elem *e)=0
Add elem e to the end of the element array.
BoundaryInfo & get_boundary_info()
Writable information about boundary ids on the mesh.
Definition mesh_base.h:175
dof_id_type n_active_local_elem() const
Definition mesh_base.h:711
bool allow_remote_element_removal() const
Definition mesh_base.h:1383
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:2467
void add_ghosting_functor(std::shared_ptr< GhostingFunctor > ghosting_functor)
Adds a functor which can specify ghosting requirements for use on distributed meshes.
Definition mesh_base.h:1456
dof_id_type n_nodes_on_proc(const processor_id_type proc) const
Definition mesh_base.C:1217
virtual void find_neighbors(const bool reset_remote_elements=false, const bool reset_current_list=true, const bool assert_valid=true, const bool check_non_remote=true)=0
Locate element face (edge in 2D) neighbors.
variant_filter_iterator< MeshBase::Predicate, Node * > node_filter_iter
Definition mesh_base.h:2506
virtual Elem * elem_ptr(const dof_id_type i)=0
std::string & subdomain_name(subdomain_id_type id)
Definition mesh_base.C:1902
bool allow_find_neighbors() const
Definition mesh_base.h:1367
virtual Elem * query_elem_ptr(const dof_id_type i)=0
void sync_subdomain_name_map()
libMesh often expects all processors to know about names of all subdomain ids, but distributed mesh g...
Definition mesh_base.C:2081
virtual const Elem & elem_ref(const dof_id_type i) const
Definition mesh_base.h:785
dof_id_type _n_constraint_rows
Definition mesh_base.h:2456
void allow_node_and_elem_unique_id_overlap(bool allow)
If true is passed, then this mesh will no longer require unique_ids to be unique across the set of al...
Definition mesh_base.h:1391
void size_node_extra_integers()
Size extra-integer arrays of all nodes in the mesh.
Definition mesh_base.C:2391
unsigned int _n_parts
The number of partitions the mesh has.
Definition mesh_base.h:2189
std::map< const Node *, constraint_rows_mapped_type > constraint_rows_type
Definition mesh_base.h:1934
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.
Definition mesh_base.C:492
unsigned char default_mapping_data() const
Returns any default data value used by the master space to physical space mapping.
Definition mesh_base.h:956
void remove_disjoint_boundary_pair(const boundary_id_type b1, const boundary_id_type b2)
Definition mesh_base.C:2321
bool operator!=(const MeshBase &other_mesh) const
Definition mesh_base.h:138
void clear_point_locator()
Releases the current PointLocator object.
Definition mesh_base.C:1881
virtual void reserve_elem(const dof_id_type ne)=0
Reserves space for a known number of elements.
virtual void gather_to_zero()
Gathers all elements and nodes of the mesh onto processor zero.
Definition mesh_base.h:392
GhostingFunctorIterator ghosting_functors_end() const
End of range of ghosting functors.
Definition mesh_base.h:1482
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?...
Definition mesh_base.C:1888
void add_ghosting_functor(GhostingFunctor &ghosting_functor)
Adds a functor which can specify ghosting requirements for use on distributed meshes.
Definition mesh_base.C:1079
void copy_constraint_rows(const MeshBase &other_mesh)
Copy the constraints from the other mesh to this mesh.
Definition mesh_base.C:2506
std::set< elemset_id_type > elemset_type
Typedef for the "set" container used to store elemset ids.
Definition mesh_base.h:463
std::set< unsigned char > _elem_dims
We cache the dimension of the elements present in the mesh.
Definition mesh_base.h:2327
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,...
Definition mesh_base.C:646
std::vector< GhostingFunctor * >::const_iterator GhostingFunctorIterator
Iterator type for ghosting functor ranges.
Definition mesh_base.h:1471
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:2395
std::unique_ptr< PointLocatorBase > sub_point_locator() const
Definition mesh_base.C:1848
virtual void libmesh_assert_valid_parallel_ids() const
Verify id and processor_id consistency of our elements and nodes containers.
Definition mesh_base.h:1702
MeshBase(MeshBase &&)=delete
Move-constructor - deleted because after a theoretical move-construction and then destruction of the ...
Predicates::multi_predicate Predicate
We need an empty, generic class to act as a predicate for this and derived mesh classes.
Definition mesh_base.h:1589
void add_disjoint_neighbor_boundary_pairs(const boundary_id_type b1, const boundary_id_type b2, const RealVectorValue &translation)
Register a pair of boundaries as disjoint neighbor boundary pairs.
Definition mesh_base.C:2287
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.
Definition mesh_base.h:2701
variant_filter_iterator< MeshBase::Predicate, Elem * > elem_filter_iter
The original iterator classes weren't properly const-safe; relying on their const-incorrectness is no...
Definition mesh_base.h:2499
std::map< subdomain_id_type, std::string > & set_subdomain_name_map()
Definition mesh_base.h:1928
unique_id_type next_unique_id() const
Definition mesh_base.h:607
subdomain_id_type get_id_by_name(std::string_view name) const
Definition mesh_base.C:1941
void print_info(std::ostream &os=libMesh::out, const unsigned int verbosity=0, const bool global=true) const
Prints relevant information about the mesh.
Definition mesh_base.C:1770
virtual void update_parallel_id_counts()=0
Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors.
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:284
dof_id_type count_constraint_rows()
Helper function for subclasses to use to set _n_constraint_rows.
Definition mesh_base.C:2487
MeshBase & interior_mesh()
Definition mesh_base.h:2058
virtual dof_id_type n_active_elem() const =0
void reinit_ghosting_functors()
Loops over ghosting functors and calls mesh_reinit()
Definition mesh_base.C:1025
Preparation _preparation
Flags indicating in what ways this mesh has been prepared.
Definition mesh_base.h:2207
virtual MeshBase & assign(MeshBase &&other_mesh)=0
Shim to allow operator = (&&) to behave like a virtual function without having to be one.
void skip_partitioning(bool skip)
If true is passed in then nothing on this mesh will be (re)partitioned.
Definition mesh_base.h:1433
void set_interior_mesh(MeshBase &int_mesh)
Sets the interior mesh.
Definition mesh_base.h:2063
subdomain_id_type n_subdomains() const
Definition mesh_base.C:1191
virtual bool is_serial_on_zero() const
Definition mesh_base.h:364
std::string get_info(const unsigned int verbosity=0, const bool global=true) const
Definition mesh_base.C:1276
std::string get_local_constraints(bool print_nonlocal=false) const
Gets a string reporting all mesh constraint rows local to this processor.
Definition mesh_base.C:2831
virtual Node & node_ref(const dof_id_type i)
Definition mesh_base.h:751
void allow_detect_interior_parents(bool allow)
If false is passed then this mesh will no longer work to detect interior parents when being prepared ...
Definition mesh_base.h:1373
bool nodes_and_elements_equal(const MeshBase &other_mesh) const
Tests for equality of all elements and nodes in the mesh.
Definition mesh_base.C:2457
void copy_cached_data(const MeshBase &other_mesh)
Helper class to copy cached data, to synchronize with a possibly unprepared other_mesh.
Definition mesh_base.C:2447
virtual void reserve_nodes(const dof_id_type nn)=0
Reserves space for a known number of nodes.
void skip_noncritical_partitioning(bool skip)
If true is passed in then the elements on this mesh will no longer be (re)partitioned,...
Definition mesh_base.h:1415
void unset_is_prepared()
Tells this we have done some operation where we should no longer consider ourself prepared.
Definition mesh_base.C:1071
void post_dofobject_moves(MeshBase &&other_mesh)
Moves any superclass data (e.g.
Definition mesh_base.C:2411
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:2092
unsigned int & set_n_partitions()
Definition mesh_base.h:2176
void clear_stored_ranges()
Clears stored ranges, to indicate that the mesh has changed and they should be regenerated when next ...
Definition mesh_base.C:1984
virtual dof_id_type parallel_n_nodes() const =0
variant_filter_iterator< MeshBase::Predicate, Node *const, Node *const &, Node *const * > const_node_filter_iter
Definition mesh_base.h:2511
virtual unique_id_type parallel_max_unique_id() const =0
std::unique_ptr< ElemRange > _element_stored_range
A cached ElemRange for threaded mutation of all semilocal elements of this mesh.
Definition mesh_base.h:2217
This is the MeshCommunication class.
This class defines an abstract interface for Mesh input.
Definition mesh_input.h:49
A Node is like a Point, but with more information.
Definition node.h:55
An object whose state is distributed along a set of processors.
processor_id_type processor_id() const
processor_id_type n_processors() const
The Partitioner class provides a uniform interface for partitioning algorithms.
Definition partitioner.h:52
We're using a class instead of a typedef to allow forward declarations and future flexibility.
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:41
The SimpleRange templated class is intended to make it easy to construct ranges from pairs of iterato...
Generic sparse matrix.
The StoredRange class defines a contiguous, divisible set of objects.
Original Authors: Corwin Joy * Michael Gradman [email protected] * Michael.Gradman@caminus....
The libMesh namespace provides an interface to certain functionality in the library.
uint8_t unique_id_type
Definition id_types.h:86
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition int_range.h:153
ElemType
Defines an enum for geometric element types.
int8_t boundary_id_type
Definition id_types.h:51
ElemMappingType
Enumeration of possible element master->physical mapping types.
libmesh_assert(ctx)
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:303
OStreamProxy out
uint8_t dof_id_type
Definition id_types.h:67
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
uint8_t processor_id_type
Definition id_types.h:104
Flags indicating in what ways a mesh has been prepared for use.
Definition mesh_base.h:2092
bool operator!=(const Preparation &other) const
Definition mesh_base.C:2935
Preparation & operator=(bool set_all)
Set all flags to the "set_all" value.
Definition mesh_base.C:2891
bool operator==(const Preparation &other) const
Two Preparation objects are equivalent iff all the flags match, regardless of the true/false status o...
Definition mesh_base.C:2908
The definition of the const_element_iterator struct.
Definition mesh_base.h:2575
const_element_iterator(const MeshBase::element_iterator &rhs)
The conversion-to-const ctor.
Definition mesh_base.h:2591
const_element_iterator(const IterType &d, const IterType &e, const PredType &p)
Templated forwarding ctor – forwards to appropriate variant_filter_iterator ctor.
Definition mesh_base.h:2580
The definition of the const_node_iterator struct.
Definition mesh_base.h:2626
const_node_iterator(const IterType &d, const IterType &e, const PredType &p)
Templated forwarding ctor – forwards to appropriate variant_filter_iterator ctor.
Definition mesh_base.h:2631
const_node_iterator(const MeshBase::node_iterator &rhs)
The conversion-to-const ctor.
Definition mesh_base.h:2642
The definition of the element_iterator struct.
Definition mesh_base.h:2557
element_iterator(const IterType &d, const IterType &e, const PredType &p)
Definition mesh_base.h:2560
The definition of the node_iterator struct.
Definition mesh_base.h:2606
node_iterator(const IterType &d, const IterType &e, const PredType &p)
Templated forwarding ctor – forwards to appropriate variant_filter_iterator ctor.
Definition mesh_base.h:2611