Reference documentation for deal.II version Git 5a2787e538 20210921 14:55:10 0600

#include <deal.II/distributed/shared_tria.h>
Public Member Functions  
Triangulation (const MPI_Comm &mpi_communicator, const typename ::Triangulation< dim, spacedim >::MeshSmoothing=(::Triangulation< dim, spacedim >::none), const bool allow_artificial_cells=false, const Settings settings=partition_auto)  
virtual  ~Triangulation () override=default 
virtual bool  is_multilevel_hierarchy_constructed () const override 
virtual void  execute_coarsening_and_refinement () override 
virtual void  create_triangulation (const std::vector< Point< spacedim >> &vertices, const std::vector< CellData< dim >> &cells, const SubCellData &subcelldata) override 
virtual void  create_triangulation (const TriangulationDescription::Description< dim, spacedim > &construction_data) override 
virtual void  copy_triangulation (const ::Triangulation< dim, spacedim > &other_tria) override 
template<class Archive >  
void  load (Archive &ar, const unsigned int version) 
const std::vector< types::subdomain_id > &  get_true_subdomain_ids_of_cells () const 
const std::vector< types::subdomain_id > &  get_true_level_subdomain_ids_of_cells (const unsigned int level) const 
bool  with_artificial_cells () const 
virtual MPI_Comm  get_communicator () const override 
virtual void  copy_triangulation (const ::Triangulation< dim, spacedim > &old_tria) override 
virtual void  copy_triangulation (const Triangulation< dim, spacedim > &other_tria) 
unsigned int  n_locally_owned_active_cells () const 
virtual types::global_cell_index  n_global_active_cells () const override 
virtual std::size_t  memory_consumption () const override 
virtual unsigned int  n_global_levels () const override 
types::subdomain_id  locally_owned_subdomain () const override 
const std::set< types::subdomain_id > &  ghost_owners () const 
const std::set< types::subdomain_id > &  level_ghost_owners () const 
const std::weak_ptr< const Utilities::MPI::Partitioner >  global_active_cell_index_partitioner () const 
const std::weak_ptr< const Utilities::MPI::Partitioner >  global_level_cell_index_partitioner (const unsigned int level) const 
virtual std::vector< types::boundary_id >  get_boundary_ids () const override 
virtual std::vector< types::manifold_id >  get_manifold_ids () const override 
void  communicate_locally_moved_vertices (const std::vector< bool > &vertex_locally_moved) 
virtual types::coarse_cell_id  n_global_coarse_cells () const override 
virtual void  clear () 
virtual void  set_mesh_smoothing (const MeshSmoothing mesh_smoothing) 
virtual const MeshSmoothing &  get_mesh_smoothing () const 
void  set_manifold (const types::manifold_id number, const Manifold< dim, spacedim > &manifold_object) 
void  reset_manifold (const types::manifold_id manifold_number) 
void  reset_all_manifolds () 
void  set_all_manifold_ids (const types::manifold_id number) 
void  set_all_manifold_ids_on_boundary (const types::manifold_id number) 
void  set_all_manifold_ids_on_boundary (const types::boundary_id b_id, const types::manifold_id number) 
const Manifold< dim, spacedim > &  get_manifold (const types::manifold_id number) const 
virtual void  create_triangulation_compatibility (const std::vector< Point< spacedim >> &vertices, const std::vector< CellData< dim >> &cells, const SubCellData &subcelldata) 
void  flip_all_direction_flags () 
template<>  
bool  prepare_coarsening_and_refinement () 
template<>  
bool  prepare_coarsening_and_refinement () 
template<>  
bool  prepare_coarsening_and_refinement () 
template<>  
unsigned int  n_quads () const 
template<>  
unsigned int  n_quads (const unsigned int) const 
template<>  
unsigned int  n_quads () const 
template<>  
unsigned int  n_quads (const unsigned int) const 
template<>  
unsigned int  n_quads () const 
template<>  
unsigned int  n_quads (const unsigned int) const 
template<>  
unsigned int  n_active_quads (const unsigned int) const 
template<>  
unsigned int  n_active_quads () const 
template<>  
unsigned int  n_active_quads (const unsigned int) const 
template<>  
unsigned int  n_active_quads () const 
template<>  
unsigned int  n_active_quads (const unsigned int) const 
template<>  
unsigned int  n_active_quads () const 
template<>  
unsigned int  n_hexs () const 
template<>  
unsigned int  n_hexs (const unsigned int level) const 
template<>  
unsigned int  n_active_hexs () const 
template<>  
unsigned int  n_active_hexs (const unsigned int level) const 
template<>  
unsigned int  max_adjacent_cells () const 
template<>  
unsigned int  max_adjacent_cells () const 
template<>  
unsigned int  max_adjacent_cells () const 
template<>  
unsigned int  n_raw_quads (const unsigned int) const 
template<>  
unsigned int  n_raw_quads (const unsigned int) const 
template<>  
unsigned int  n_raw_quads (const unsigned int) const 
template<>  
unsigned int  n_raw_quads (const unsigned int level) const 
template<>  
unsigned int  n_raw_quads (const unsigned int level) const 
template<>  
unsigned int  n_raw_quads (const unsigned int) const 
template<>  
unsigned int  n_raw_quads () const 
template<>  
unsigned int  n_raw_hexs (const unsigned int) const 
template<>  
unsigned int  n_raw_hexs (const unsigned int) const 
template<>  
unsigned int  n_raw_hexs (const unsigned int) const 
template<>  
unsigned int  n_raw_hexs (const unsigned int level) const 
Mesh refinement  
void  set_all_refine_flags () 
void  refine_global (const unsigned int times=1) 
void  coarsen_global (const unsigned int times=1) 
virtual bool  prepare_coarsening_and_refinement () 
History of a triangulation  
void  save_refine_flags (std::ostream &out) const 
void  save_refine_flags (std::vector< bool > &v) const 
void  load_refine_flags (std::istream &in) 
void  load_refine_flags (const std::vector< bool > &v) 
void  save_coarsen_flags (std::ostream &out) const 
void  save_coarsen_flags (std::vector< bool > &v) const 
void  load_coarsen_flags (std::istream &out) 
void  load_coarsen_flags (const std::vector< bool > &v) 
bool  get_anisotropic_refinement_flag () const 
User data  
void  clear_user_flags () 
void  save_user_flags (std::ostream &out) const 
void  save_user_flags (std::vector< bool > &v) const 
void  load_user_flags (std::istream &in) 
void  load_user_flags (const std::vector< bool > &v) 
void  clear_user_flags_line () 
void  save_user_flags_line (std::ostream &out) const 
void  save_user_flags_line (std::vector< bool > &v) const 
void  load_user_flags_line (std::istream &in) 
void  load_user_flags_line (const std::vector< bool > &v) 
void  clear_user_flags_quad () 
void  save_user_flags_quad (std::ostream &out) const 
void  save_user_flags_quad (std::vector< bool > &v) const 
void  load_user_flags_quad (std::istream &in) 
void  load_user_flags_quad (const std::vector< bool > &v) 
void  clear_user_flags_hex () 
void  save_user_flags_hex (std::ostream &out) const 
void  save_user_flags_hex (std::vector< bool > &v) const 
void  load_user_flags_hex (std::istream &in) 
void  load_user_flags_hex (const std::vector< bool > &v) 
void  clear_user_data () 
void  save_user_indices (std::vector< unsigned int > &v) const 
void  load_user_indices (const std::vector< unsigned int > &v) 
void  save_user_pointers (std::vector< void *> &v) const 
void  load_user_pointers (const std::vector< void *> &v) 
void  save_user_indices_line (std::vector< unsigned int > &v) const 
void  load_user_indices_line (const std::vector< unsigned int > &v) 
void  save_user_indices_quad (std::vector< unsigned int > &v) const 
void  load_user_indices_quad (const std::vector< unsigned int > &v) 
void  save_user_indices_hex (std::vector< unsigned int > &v) const 
void  load_user_indices_hex (const std::vector< unsigned int > &v) 
void  save_user_pointers_line (std::vector< void *> &v) const 
void  load_user_pointers_line (const std::vector< void *> &v) 
void  save_user_pointers_quad (std::vector< void *> &v) const 
void  load_user_pointers_quad (const std::vector< void *> &v) 
void  save_user_pointers_hex (std::vector< void *> &v) const 
void  load_user_pointers_hex (const std::vector< void *> &v) 
Cell iterator functions  
cell_iterator  begin (const unsigned int level=0) const 
active_cell_iterator  begin_active (const unsigned int level=0) const 
cell_iterator  end () const 
cell_iterator  end (const unsigned int level) const 
active_cell_iterator  end_active (const unsigned int level) const 
cell_iterator  last () const 
active_cell_iterator  last_active () const 
cell_iterator  create_cell_iterator (const CellId &cell_id) const 
Cell iterator functions returning ranges of iterators  
IteratorRange< cell_iterator >  cell_iterators () const 
IteratorRange< active_cell_iterator >  active_cell_iterators () const 
IteratorRange< cell_iterator >  cell_iterators_on_level (const unsigned int level) const 
IteratorRange< active_cell_iterator >  active_cell_iterators_on_level (const unsigned int level) const 
Face iterator functions  
face_iterator  begin_face () const 
active_face_iterator  begin_active_face () const 
face_iterator  end_face () const 
IteratorRange< active_face_iterator >  active_face_iterators () const 
Vertex iterator functions  
vertex_iterator  begin_vertex () const 
active_vertex_iterator  begin_active_vertex () const 
vertex_iterator  end_vertex () const 
Information about the triangulation  
unsigned int  n_lines () const 
unsigned int  n_lines (const unsigned int level) const 
unsigned int  n_active_lines () const 
unsigned int  n_active_lines (const unsigned int level) const 
unsigned int  n_quads () const 
unsigned int  n_quads (const unsigned int level) const 
unsigned int  n_active_quads () const 
unsigned int  n_active_quads (const unsigned int level) const 
unsigned int  n_hexs () const 
unsigned int  n_hexs (const unsigned int level) const 
unsigned int  n_active_hexs () const 
unsigned int  n_active_hexs (const unsigned int level) const 
unsigned int  n_cells () const 
unsigned int  n_cells (const unsigned int level) const 
unsigned int  n_active_cells () const 
unsigned int  n_active_cells (const unsigned int level) const 
unsigned int  n_faces () const 
unsigned int  n_active_faces () const 
unsigned int  n_levels () const 
virtual bool  has_hanging_nodes () const 
unsigned int  n_vertices () const 
const std::vector< Point< spacedim > > &  get_vertices () const 
unsigned int  n_used_vertices () const 
bool  vertex_used (const unsigned int index) const 
const std::vector< bool > &  get_used_vertices () const 
unsigned int  max_adjacent_cells () const 
Triangulation< dim, spacedim > &  get_triangulation () 
const Triangulation< dim, spacedim > &  get_triangulation () const 
Internal information about the number of objects  
unsigned int  n_raw_lines () const 
unsigned int  n_raw_lines (const unsigned int level) const 
unsigned int  n_raw_quads () const 
unsigned int  n_raw_quads (const unsigned int level) const 
unsigned int  n_raw_hexs (const unsigned int level) const 
unsigned int  n_raw_cells (const unsigned int level) const 
unsigned int  n_raw_faces () const 
template<class Archive >  
void  save (Archive &ar, const unsigned int version) const 
virtual void  add_periodicity (const std::vector< GridTools::PeriodicFacePair< cell_iterator >> &) 
const std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > &  get_periodic_face_map () const 
const std::vector< ReferenceCell > &  get_reference_cells () const 
bool  all_reference_cells_are_hyper_cube () const 
template<class Archive >  
void  serialize (Archive &archive, const unsigned int version) 
Subscriptor functionality  
Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.  
void  subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const 
void  unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const 
unsigned int  n_subscriptions () const 
template<typename StreamType >  
void  list_subscribers (StreamType &stream) const 
void  list_subscribers () const 
Static Public Member Functions  
static ::ExceptionBase &  ExcInUse (int arg1, std::string arg2, std::string arg3) 
static ::ExceptionBase &  ExcNoSubscriber (std::string arg1, std::string arg2) 
Static Public Attributes  
static const unsigned int  dimension = dim 
static const unsigned int  space_dimension = spacedim 
Protected Member Functions  
virtual void  update_number_cache () 
void  update_reference_cells () override 
void  reset_global_cell_indices () 
Protected Attributes  
const MPI_Comm  mpi_communicator 
types::subdomain_id  my_subdomain 
types::subdomain_id  n_subdomains 
NumberCache  number_cache 
Private Member Functions  
void  partition () 
Private Attributes  
const Settings  settings 
const bool  allow_artificial_cells 
std::vector< types::subdomain_id >  true_subdomain_ids_of_cells 
std::vector< std::vector< types::subdomain_id > >  true_level_subdomain_ids_of_cells 
Keeping up with what happens to a triangulation  
enum  CellStatus { CELL_PERSIST, CELL_REFINE, CELL_COARSEN, CELL_INVALID } 
Signals  signals 
Exceptions  
MeshSmoothing  smooth_grid 
std::vector< ReferenceCell >  reference_cells 
void  update_periodic_face_map () 
static ::ExceptionBase &  ExcInvalidLevel (int arg1, int arg2) 
static ::ExceptionBase &  ExcTriangulationNotEmpty (int arg1, int arg2) 
static ::ExceptionBase &  ExcGridReadError () 
static ::ExceptionBase &  ExcFacesHaveNoLevel () 
static ::ExceptionBase &  ExcEmptyLevel (int arg1) 
static ::ExceptionBase &  ExcNonOrientableTriangulation () 
static ::ExceptionBase &  ExcBoundaryIdNotFound (types::boundary_id arg1) 
static ::ExceptionBase &  ExcInconsistentCoarseningFlags () 
static void  write_bool_vector (const unsigned int magic_number1, const std::vector< bool > &v, const unsigned int magic_number2, std::ostream &out) 
static void  read_bool_vector (const unsigned int magic_number1, std::vector< bool > &v, const unsigned int magic_number2, std::istream &in) 
This class provides a parallel triangulation for which every processor knows about every cell of the global mesh (unlike for the parallel::distributed::Triangulation class) but in which cells are automatically partitioned when run with MPI so that each processor "owns" a subset of cells. The use of this class is demonstrated in step18.
Different from the parallel::distributed::Triangulation and parallel::fullydistributed::Triangulation classes, this implies that the entire mesh is stored on each processor. While this is clearly a memory bottleneck that limits the use of this class to a few dozen or hundreds of MPI processes, the partitioning of the mesh can be used to partition work such as assembly or postprocessing between participating processors, and it can also be used to partition which processor stores which parts of matrices and vectors. As a consequence, using this class is often a gentler introduction to parallelizing a code than the more involved parallel::distributed::Triangulation class in which processors only know their own part of the mesh, but nothing about cells owned by other processors with the exception of a single layer of ghost cells around their own part of the domain.
As a consequence of storing the entire mesh on each processor, active cells need to be flagged for refinement or coarsening consistently on all processors if you want to adapt them, regardless of being classified as locally owned, ghost or artificial.
The class is also useful in cases where compute time and memory considerations dictate that the program needs to be run in parallel, but where algorithmic concerns require that every processor knows about the entire mesh. An example could be where an application has to have both volume and surface meshes that can then both be partitioned independently, but where it is difficult to ensure that the locally owned set of surface mesh cells is adjacent to the locally owned set of volume mesh cells and the other way around. In such cases, knowing the entirety of both meshes ensures that assembly of coupling terms can be implemented without also implementing overly complicated schemes to transfer information about adjacent cells from processor to processor.
The partitioning of cells between processors is done internally based on a number of different possibilities. By passing appropriate flags to the constructor of this class (see the parallel::shared::Triangulation::Settings enum), it is possible to select different ways of partitioning the mesh, including ways that are dictated by the application and not by the desire to minimize the length of the interface between subdomains owned by processors (as is done by the METIS and Zoltan packages, both of which are options for partitioning). The DoFHandler class knows how to enumerate degrees of freedom in ways appropriate for the partitioned mesh.
Definition at line 105 of file shared_tria.h.
using parallel::shared::Triangulation< dim, spacedim >::active_cell_iterator = typename ::Triangulation<dim, spacedim>::active_cell_iterator 
Definition at line 110 of file shared_tria.h.
using parallel::shared::Triangulation< dim, spacedim >::cell_iterator = typename ::Triangulation<dim, spacedim>::cell_iterator 
Definition at line 112 of file shared_tria.h.

inherited 
enum parallel::shared::Triangulation::Settings 
Configuration flags for distributed Triangulations to be set in the constructor. Settings can be combined using bitwise OR.
The constructor requires that exactly one of partition_auto
, partition_metis
, partition_zorder
, partition_zoltan
and partition_custom_signal
is set. If partition_auto
is chosen, it will use partition_zoltan
(if available), then partition_metis
(if available) and finally partition_zorder
.
Enumerator  

partition_auto  Choose the partitioner depending on the enabled dependencies that were found when configuring deal.II. In particular, if the Trilinos package Zoltan was found, then use the 
partition_metis  Use METIS partitioner to partition active cells. 
partition_zorder  Partition active cells with the same scheme used in the p4est library. The term "Zorder" originates in the fact that cells are sorted using a space filling curve which in 2d connects the four children of a cell in the order bottom left, bottom right, top left, top right (i.e., with a curve that looks like a reverse "Z"), and does so recursively on all levels of a triangulation. This is also the order in which children are enumerated by the GeometryInfo class. The "Zorder" is also sometimes called "Morton ordering", see https://en.wikipedia.org/wiki/Zorder_curve .

partition_zoltan  Use Zoltan to partition active cells. 
partition_custom_signal  Partition cells using a custom, user defined function. This is accomplished by connecting the post_refinement signal to the triangulation whenever it is first created and passing the user defined function through the signal using template <int dim> void mypartition(parallel::shared::Triangulation<dim> &tria) { // user defined partitioning scheme: assign subdomain_ids // roundrobin in a mostly random way: std::vector<unsigned int> assignment = {0,0,1,2,0,0,2,1,0,2,2,1,2,2,0,0}; unsigned int index = 0; cell>set_subdomain_id(assignment[(index++)%16]); } int main () { ..., tria.signals.post_refinement.connect(std::bind(&mypartition<dim>, std::ref(tria))); } An equivalent code using lambda functions would look like this: int main () { ..., tria.signals.post_refinement.connect ( [&tria]() { // user defined partitioning scheme as above ... }); }

construct_multigrid_hierarchy  This flag needs to be set to use the geometric multigrid functionality. This option requires additional computation and communication. Note: This flag should always be set alongside a flag for an active cell partitioning method. 
Definition at line 127 of file shared_tria.h.

inherited 
Declare some symbolic names for mesh smoothing algorithms. The meaning of these flags is documented in the Triangulation class.
Enumerator  

none  No mesh smoothing at all, except that meshes have to remain one irregular. 
limit_level_difference_at_vertices  It can be shown, that degradation of approximation occurs if the triangulation contains vertices which are member of cells with levels differing by more than one. One such example is the following: It would seem that in two space dimensions, the maximum jump in levels between cells sharing a common vertex is two (as in the example above). However, this is not true if more than four cells meet at a vertex. It is not uncommon that a coarse (initial) mesh contains vertices at which six or even eight cells meet, when small features of the domain have to be resolved even on the coarsest mesh. In that case, the maximum difference in levels is three or four, respectively. The problem gets even worse in three space dimensions. Looking at an interpolation of the second derivative of the finite element solution (assuming bilinear finite elements), one sees that the numerical solution is almost totally wrong, compared with the true second derivative. Indeed, on regular meshes, there exist sharp estimations that the H^{2}error is only of order one, so we should not be surprised; however, the numerical solution may show a value for the second derivative which may be a factor of ten away from the true value. These problems are located on the small cell adjacent to the center vertex, where cells of nonsubsequent levels meet, as well as on the upper and right neighbor of this cell (but with a less degree of deviation from the true value). If the smoothing indicator given to the constructor contains the bit for limit_level_difference_at_vertices, situations as the above one are eliminated by also marking the upper right cell for refinement. In case of anisotropic refinement, the level of a cell is not linked to the refinement of a cell as directly as in case of isotropic refinement. Furthermore, a cell can be strongly refined in one direction and not or at least much less refined in another. Therefore, it is very difficult to decide, which cases should be excluded from the refinement process. As a consequence, when using anisotropic refinement, the limit_level_difference_at_vertices flag must not be set. On the other hand, the implementation of multigrid methods in deal.II requires that this bit be set. 
eliminate_unrefined_islands  Single cells which are not refined and are surrounded by cells which are refined usually also lead to a sharp decline in approximation properties locally. The reason is that the nodes on the faces between unrefined and refined cells are not real degrees of freedom but carry constraints. The patch without additional degrees of freedom is thus significantly larger then the unrefined cell itself. If in the parameter passed to the constructor the bit for eliminate_unrefined_islands is set, all cells which are not flagged for refinement but which are surrounded by more refined cells than unrefined cells are flagged for refinement. Cells which are not yet refined but flagged for that are accounted for the number of refined neighbors. Cells on the boundary are not accounted for at all. An unrefined island is, by this definition also a cell which (in 2D) is surrounded by three refined cells and one unrefined one, or one surrounded by two refined cells, one unrefined one and is at the boundary on one side. It is thus not a true island, as the name of the flag may indicate. However, no better name came to mind to the author by now. 
patch_level_1  A triangulation of patch level 1 consists of patches, i.e. of cells that are refined once. This flag ensures that a mesh of patch level 1 is still of patch level 1 after coarsening and refinement. It is, however, the user's responsibility to ensure that the mesh is of patch level 1 before calling Triangulation::execute_coarsening_and_refinement() the first time. The easiest way to achieve this is by calling global_refine(1) straight after creation of the triangulation. It follows that if at least one of the children of a cell is or will be refined than all children need to be refined. If the patch_level_1 flag is set, than the flags eliminate_unrefined_islands, eliminate_refined_inner_islands and eliminate_refined_boundary_islands will be ignored as they will be fulfilled automatically. 
coarsest_level_1  Each coarse grid cell is refined at least once, i.e., the triangulation might have active cells on level 1 but not on level 0. This flag ensures that a mesh which has coarsest_level_1 has still coarsest_level_1 after coarsening and refinement. It is, however, the user's responsibility to ensure that the mesh has coarsest_level_1 before calling execute_coarsening_and_refinement the first time. The easiest way to achieve this is by calling global_refine(1) straight after creation of the triangulation. It follows that active cells on level 1 may not be coarsened. The main use of this flag is to ensure that each cell has at least one neighbor in each coordinate direction (i.e. each cell has at least a left or right, and at least an upper or lower neighbor in 2d). This is a necessary precondition for some algorithms that compute finite differences between cells. The DerivativeApproximation class is one of these algorithms that require that a triangulation is coarsest_level_1 unless all cells already have at least one neighbor in each coordinate direction on the coarsest level. 
allow_anisotropic_smoothing  This flag is not included in However, in many cases it is sufficient to refine the coarser of the two original cells in an anisotropic way to avoid the case of multiple hanging vertices on a single edge. Doing only the minimal anisotropic refinement can save cells and degrees of freedom. By specifying this flag, the library can produce these anisotropic refinements. The flag is not included by default since it may lead to anisotropically refined meshes even though no cell has ever been refined anisotropically explicitly by a user command. This surprising fact may lead to programs that do the wrong thing since they are not written for the additional cases that can happen with anisotropic meshes, see the discussion in the introduction to step30. 
eliminate_refined_inner_islands  This algorithm seeks for isolated cells which are refined or flagged for refinement. This definition is unlike that for eliminate_unrefined_islands, which would mean that an island is defined as a cell which is refined but more of its neighbors are not refined than are refined. For example, in 2D, a cell's refinement would be reverted if at most one of its neighbors is also refined (or refined but flagged for coarsening). The reason for the change in definition of an island is, that this option would be a bit dangerous, since if you consider a chain of refined cells (e.g. along a kink in the solution), the cells at the two ends would be coarsened, after which the next outermost cells would need to be coarsened. Therefore, only one loop of flagging cells like this could be done to avoid eating up the whole chain of refined cells (`chain reaction'...). This algorithm also takes into account cells which are not actually refined but are flagged for refinement. If necessary, it takes away the refinement flag. Actually there are two versions of this flag, eliminate_refined_inner_islands and eliminate_refined_boundary_islands. The first eliminates islands defined by the definition above which are in the interior of the domain, while the second eliminates only those islands if the cell is at the boundary. The reason for this split of flags is that one often wants to eliminate such islands in the interior while those at the boundary may well be wanted, for example if one refines the mesh according to a criterion associated with a boundary integral or if one has rough boundary data. 
eliminate_refined_boundary_islands  The result of this flag is very similar to eliminate_refined_inner_islands. See the documentation there. 
do_not_produce_unrefined_islands  This flag prevents the occurrence of unrefined islands. In more detail: It prohibits the coarsening of a cell if 'most of the neighbors' will be refined after the step. 
smoothing_on_refinement  This flag sums up all smoothing algorithms which may be performed upon refinement by flagging some more cells for refinement. 
smoothing_on_coarsening  This flag sums up all smoothing algorithms which may be performed upon coarsening by flagging some more cells for coarsening. 
maximum_smoothing  This flag includes all the above ones (therefore combines all smoothing algorithms implemented), with the exception of anisotropic smoothing. 

inherited 
Used to inform functions in derived classes how the cell with the given cell_iterator is going to change. Note that this may me different than the refine_flag() and coarsen_flag() in the cell_iterator in parallel calculations because of refinement constraints that this machine does not see.
Triangulation< dim, spacedim >::Triangulation  (  const MPI_Comm &  mpi_communicator, 
const typename ::Triangulation< dim, spacedim >::MeshSmoothing  smooth_grid = (::Triangulation<dim, spacedim>::none) , 

const bool  allow_artificial_cells = false , 

const Settings  settings = partition_auto 

) 
Constructor.
The flag allow_artificial_cells
can be used to enable artificial cells. If enabled, this class will behave similarly to parallel::distributed::Triangulation and parallel::fullydistributed::Triangulation in the sense that there will be locally owned cells, a single layer of ghost cells, and artificial cells. However, one should not forget that in contrast to those parallel triangulations all cells are duplicated on all processes, leading in most cases to significantly more artificial cells.
If artificial cells are disabled, all nonlocally owned cells are considered ghost cells. This might lead to very expensive ghostvalue update steps. While in the case of artificial cells, ghostvalue updates lead to communication only with the direct process neighbors in a pointtopoint fashion, these degenerate to an operation in which every process communicates with every other process (an "alltoall" communication) if no artificial cells are available. If such ghostvalue updates are the bottleneck in your code, you may want to consider enabling artificial cells.
Definition at line 39 of file shared_tria.cc.

overridevirtualdefault 
Destructor.
Reimplemented from Triangulation< dim, spacedim >.

overridevirtual 
Return if multilevel hierarchy is supported and has been constructed.
Implements parallel::TriangulationBase< dim, spacedim >.
Definition at line 74 of file shared_tria.cc.

overridevirtual 
Coarsen and refine the mesh according to refinement and coarsening flags set.
This step is equivalent to the Triangulation class with an addition of calling GridTools::partition_triangulation() at the end.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 357 of file shared_tria.cc.

overridevirtual 
Create a triangulation.
This function also partitions triangulation based on the MPI communicator provided to the constructor.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 368 of file shared_tria.cc.

overridevirtual 
Create a triangulation.
This function also partitions triangulation based on the MPI communicator provided to the constructor.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 394 of file shared_tria.cc.

overridevirtual 
Copy other_tria
to this triangulation.
This function also partitions triangulation based on the MPI communicator provided to the constructor.
Definition at line 407 of file shared_tria.cc.
void Triangulation< dim, spacedim >::load  (  Archive &  ar, 
const unsigned int  version  
) 
Read the data of this object from a stream for the purpose of serialization. Throw away the previous content.
This function first does the same work as in Triangulation::load, then partitions the triangulation based on the MPI communicator provided to the constructor.
Definition at line 407 of file shared_tria.h.
const std::vector< types::subdomain_id > & Triangulation< dim, spacedim >::get_true_subdomain_ids_of_cells  (  )  const 
Return a vector of length Triangulation::n_active_cells() where each element stores the subdomain id of the owner of this cell. The elements of the vector are obviously the same as the subdomain ids for locally owned and ghost cells, but are also correct for artificial cells that do not store who the owner of the cell is in their subdomain_id field.
Definition at line 333 of file shared_tria.cc.
const std::vector< types::subdomain_id > & Triangulation< dim, spacedim >::get_true_level_subdomain_ids_of_cells  (  const unsigned int  level  )  const 
Return a vector of length Triangulation::n_cells(level) where each element stores the level subdomain id of the owner of this cell. The elements of the vector are obviously the same as the level subdomain ids for locally owned and ghost cells, but are also correct for artificial cells that do not store who the owner of the cell is in their level_subdomain_id field.
Definition at line 342 of file shared_tria.cc.
bool Triangulation< dim, spacedim >::with_artificial_cells  (  )  const 
Return allow_artificial_cells, namely true if artificial cells are allowed.
Definition at line 324 of file shared_tria.cc.

private 
This function calls GridTools::partition_triangulation () and if requested in the constructor of the class marks artificial cells.
Definition at line 83 of file shared_tria.cc.

overridevirtualinherited 
Return MPI communicator used by this triangulation.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 141 of file tria_base.cc.

overridevirtualinherited 
Implementation of the same function as in the base class.
Definition at line 65 of file tria_base.cc.

virtualinherited 
Copy other_tria
to this triangulation. This operation is not cheap, so you should be careful with using this. We do not implement this function as a copy constructor, since it makes it easier to maintain collections of triangulations if you can assign them values later on.
Keep in mind that this function also copies the pointer to the boundary descriptor previously set by the set_manifold
function. You must therefore also guarantee that the Manifold objects describing the boundary have a lifetime at least as long as the copied triangulation.
This triangulation must be empty beforehand.
The function is made virtual
since some derived classes might want to disable or extend the functionality of this function.
Reimplemented in PersistentTriangulation< dim, spacedim >.

inherited 
Return the number of active cells in the triangulation that are locally owned, i.e. that have a subdomain_id equal to locally_owned_subdomain(). Note that there may be more active cells in the triangulation stored on the present processor, such as for example ghost cells, or cells further away from the locally owned block of cells but that are needed to ensure that the triangulation that stores this processor's set of active cells still remains balanced with respect to the 2:1 size ratio of adjacent cells.
As a consequence of the remark above, the result of this function is always smaller or equal to the result of the function with the same name in the Triangulation base class, which includes the active ghost and artificial cells (see also GlossArtificialCell and GlossGhostCell).
Definition at line 120 of file tria_base.cc.

overridevirtualinherited 
Return the sum over all processors of the number of active cells owned by each processor. This equals the overall number of active cells in the triangulation.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 134 of file tria_base.cc.

overridevirtualinherited 
Return the local memory consumption in bytes.
Reimplemented from Triangulation< dim, spacedim >.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
Definition at line 90 of file tria_base.cc.

overridevirtualinherited 
Return the global maximum level. This may be bigger than the number Triangulation::n_levels() (a function in this class's base class) returns if the current processor only stores cells in parts of the domain that are not very refined, but if other processors store cells in more deeply refined parts of the domain.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 127 of file tria_base.cc.

overridevirtualinherited 
Return the subdomain id of those cells that are owned by the current processor. All cells in the triangulation that do not have this subdomain id are either owned by another processor or have children that only exist on other processors.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 318 of file tria_base.cc.

inherited 
Return a set of MPI ranks of the processors that have at least one ghost cell adjacent to the cells of the local processor. In other words, this is the set of subdomain_id() for all ghost cells.
The returned sets are symmetric, that is if i
is contained in the list of processor j
, then j
will also be contained in the list of processor i
.
Definition at line 327 of file tria_base.cc.

inherited 
Return a set of MPI ranks of the processors that have at least one level ghost cell adjacent to our cells used in geometric multigrid. In other words, this is the set of level_subdomain_id() for all level ghost cells.
The returned sets are symmetric, that is if i
is contained in the list of processor j
, then j
will also be contained in the list of processor i
.
Definition at line 336 of file tria_base.cc.

inherited 
Return partitioner for the global indices of the cells on the active level of the triangulation.
Definition at line 632 of file tria_base.cc.

inherited 
Return partitioner for the global indices of the cells on the given level
of the triangulation.
Definition at line 639 of file tria_base.cc.

overridevirtualinherited 
Return a vector containing all boundary indicators assigned to boundary faces of active cells of this Triangulation object. Note, that each boundary indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 345 of file tria_base.cc.

overridevirtualinherited 
Return a vector containing all manifold indicators assigned to the objects of the active cells of this Triangulation. Note, that each manifold indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 356 of file tria_base.cc.

inherited 
When vertices have been moved locally, for example using code like
then this function can be used to update the location of vertices between MPI processes.
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved
argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor \(i\) move those vertices that are adjacent to cells whose owners include processor \(i\) but no other processor \(j\) with \(j<i\); in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
vertex_locally_moved
argument may not contain vertices that aren't at least on ghost cells.vertex_locally_moved  A bitmap indicating which vertices have been moved. The size of this array must be equal to Triangulation::n_vertices() and must be a subset of those vertices flagged by GridTools::get_locally_owned_vertices(). 
Definition at line 582 of file tria_base.cc.

overridevirtualinherited 
Return the total number of coarse cells. If the coarse mesh is replicated on each process, this simply returns n_cells(0)
.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 652 of file tria_base.cc.

protectedvirtualinherited 
Update the number_cache variable after mesh creation or refinement.
Reimplemented in parallel::fullydistributed::Triangulation< dim, spacedim >.
Definition at line 149 of file tria_base.cc.

overrideprotectedvirtualinherited 
Update the internal reference_cells vector.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 291 of file tria_base.cc.

protectedinherited 
Reset global active cell indices and global level cell indices.
Definition at line 367 of file tria_base.cc.

virtualinherited 
Reset this triangulation into a virgin state by deleting all data.
Note that this operation is only allowed if no subscriptions to this object exist any more, such as DoFHandler objects using it.
Reimplemented in parallel::DistributedTriangulationBase< dim, spacedim >, parallel::DistributedTriangulationBase< 1, spacedim >, parallel::DistributedTriangulationBase< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::distributed::Triangulation< dim >.

virtualinherited 

virtualinherited 

virtualinherited 
For backward compatibility, only. This function takes the cell data in the ordering as requested by deal.II versions up to 5.2, converts it to the new (lexicographic) ordering and calls create_triangulation().
Reimplemented in PersistentTriangulation< dim, spacedim >.

inherited 
Revert or flip the direction_flags of a dim<spacedim triangulation, see GlossDirectionFlag.
This function throws an exception if dim equals spacedim.

inherited 
Flag all active cells for refinement. This will refine all cells of all levels which are not already refined (i.e. only cells are refined which do not yet have children). The cells are only flagged, not refined, thus you have the chance to save the refinement flags.

inherited 
Refine all cells times
times. In other words, in each one of the times
iterations, loop over all cells and refine each cell uniformly into \(2^\text{dim}\) children. In practice, this function repeats the following operations times
times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of \((2^\text{dim})^\text{times}=2^{\text{dim} \times \text{times}}\).
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
times > 1
) . See the section on signals in the general documentation of this class.

inherited 
Coarsen all cells the given number of times.
In each of one of the times
iterations, all cells will be marked for coarsening. If an active cell is already on the coarsest level, it will be ignored.
times > 1
) . See the section on signals in the general documentation of this class.

virtualinherited 
Do both preparation for refinement and coarsening as well as mesh smoothing.
Regarding the refinement process it fixes the closure of the refinement in dim>=2
(make sure that no two cells are adjacent with a refinement level differing with more than one), etc. It performs some mesh smoothing if the according flag was given to the constructor of this class. The function returns whether additional cells have been flagged for refinement.
See the general doc of this class for more information on smoothing upon refinement.
Regarding the coarsening part, flagging and deflagging cells in preparation of the actual coarsening step are done. This includes deleting coarsen flags from cells which may not be deleted (e.g. because one neighbor is more refined than the cell), doing some smoothing, etc.
The effect is that only those cells are flagged for coarsening which will actually be coarsened. This includes the fact that all flagged cells belong to parent cells of which all children are flagged.
The function returns whether some cells' flagging has been changed in the process.
This function uses the user flags, so store them if you still need them afterwards.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 
Clear all user flags. See also GlossUserFlags.

inherited 
Save all user flags. See the general documentation for this class and the documentation for the save_refine_flags
for more details. See also GlossUserFlags.

inherited 
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

inherited 
Read the information stored by save_user_flags
. See also GlossUserFlags.

inherited 
Read the information stored by save_user_flags
. See also GlossUserFlags.

inherited 
Clear all user flags on lines. See also GlossUserFlags.

inherited 
Save the user flags on lines. See also GlossUserFlags.

inherited 
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

inherited 
Load the user flags located on lines. See also GlossUserFlags.

inherited 
Load the user flags located on lines. See also GlossUserFlags.

inherited 
Clear all user flags on quads. See also GlossUserFlags.

inherited 
Save the user flags on quads. See also GlossUserFlags.

inherited 
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

inherited 
Load the user flags located on quads. See also GlossUserFlags.

inherited 
Load the user flags located on quads. See also GlossUserFlags.

inherited 
Clear all user flags on quads. See also GlossUserFlags.

inherited 
Save the user flags on hexs. See also GlossUserFlags.

inherited 
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

inherited 
Load the user flags located on hexs. See also GlossUserFlags.

inherited 
Load the user flags located on hexs. See also GlossUserFlags.

inherited 
Clear all user pointers and indices and allow the use of both for next access. See also GlossUserData.

inherited 
Save all user indices. The output vector is resized if necessary. See also GlossUserData.

inherited 
Read the information stored by save_user_indices(). See also GlossUserData.

inherited 
Save all user pointers. The output vector is resized if necessary. See also GlossUserData.

inherited 
Read the information stored by save_user_pointers(). See also GlossUserData.

inherited 
Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user indices located on lines. See also GlossUserData.

inherited 
Save the user indices on quads. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user indices located on quads. See also GlossUserData.

inherited 
Save the user indices on hexes. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user indices located on hexs. See also GlossUserData.

inherited 
Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user pointers located on lines. See also GlossUserData.

inherited 
Save the user pointers on quads. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user pointers located on quads. See also GlossUserData.

inherited 
Save the user pointers on hexes. The output vector is resized if necessary. See also GlossUserData.

inherited 
Load the user pointers located on hexs. See also GlossUserData.

inherited 
Iterator to the first used cell on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

inherited 
Iterator to the first active cell on level level
. If the given level does not contain any active cells (i.e., all cells on this level are further refined, then this function returns end_active(level)
so that loops of the kind
have zero iterations, as may be expected if there are no active cells on this level.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

inherited 

inherited 
Return an iterator which is the first iterator not on level. If level
is the last level, then this returns end()
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

inherited 
Return an active iterator which is the first active iterator not on the given level. If level
is the last level, then this returns end()
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

inherited 

inherited 

inherited 
Return an iterator to a cell of this Triangulation object constructed from an independent CellId object.
If the given argument corresponds to a valid cell in this triangulation, this operation will always succeed for sequential triangulations where the current processor stores all cells that are part of the triangulation. On the other hand, if this is a parallel triangulation, then the current processor may not actually know about this cell. In this case, this operation will succeed for locally relevant cells, but may not for artificial cells that are less refined on the current processor.

inherited 

inherited 

inherited 

inherited 

inherited 
Iterator to the first active vertex. Because all vertices are active, begin_vertex() and begin_active_vertex() return the same vertex. This function can only be used if dim is not one.

inherited 

inherited 
In the following, most functions are provided in two versions, with and without an argument describing the level. The versions with this argument are only applicable for objects describing the cells of the present triangulation. For example: in 2D n_lines(level)
cannot be called, only n_lines()
, as lines are faces in 2D and therefore have no level. Return the total number of used lines, active or not.

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 
Return the total number of active cells. Maps to n_active_lines()
in one space dimension and so on.

inherited 

inherited 

inherited 
Return the total number of active faces. In 2D, the result equals n_active_lines(), in 3D it equals n_active_quads(), while in 1D it equals the number of used vertices.

inherited 
Return the number of levels in this triangulation.

virtualinherited 
Return true if the triangulation has hanging nodes.
The function is made virtual since the result can be interpreted in different ways, depending on whether the triangulation lives only on a single processor, or may be distributed as done in the parallel::distributed::Triangulation class (see there for a description of what the function is supposed to do in the parallel context).
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.

inherited 
Return the total number of vertices. Some of them may not be used, which usually happens upon coarsening of a triangulation when some vertices are discarded, but we do not want to renumber the remaining ones, leading to holes in the numbers of used vertices. You can get the number of used vertices using n_used_vertices
function.

inherited 
Return a constant reference to all the vertices present in this triangulation. Note that not necessarily all vertices in this array are actually used; for example, if you coarsen a mesh, then some vertices are deleted, but their positions in this array are unchanged as the indices of vertices are only allocated once. You can find out about which vertices are actually used by the function get_used_vertices().

inherited 

inherited 
Return true
if the vertex with this index
is used.

inherited 

inherited 
Return the maximum number of cells meeting at a common vertex. Since this number is an invariant under refinement, only the cells on the coarsest level are considered. The operation is thus reasonably fast. The invariance is only true for sufficiently many cells in the coarsest triangulation (e.g. for a single cell one would be returned), so a minimum of four is returned in two dimensions, 8 in three dimensions, etc, which is how many cells meet if the triangulation is refined.
In one space dimension, two is returned.

inherited 

inherited 

inherited 

inherited 
Return a reference to the current object.
This doesn't seem to be very useful but allows to write code that can access the underlying triangulation for anything that satisfies the MeshType concept (which may not only be a triangulation, but also a DoFHandler, for example).

inherited 

inherited 
Total number of lines, used or unused.

inherited 
Number of lines, used or unused, on the given level.

inherited 
Total number of quads, used or unused.

inherited 
Number of quads, used or unused, on the given level.

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 

inherited 
Number of hexs, used or unused, on the given level.

inherited 

inherited 

inherited 

inherited 

inherited 
Number of cells, used or unused, on the given level.

inherited 
Return the total number of faces, used or not. In 2d, the result equals n_raw_lines(), in 3d it equals n_raw_quads(), while in 1D it equals the number of vertices.

inherited 
Write the data of this object to a stream for the purpose of serialization using the BOOST serialization library.

virtualinherited 
Declare the (coarse) face pairs given in the argument of this function as periodic. This way it is possible to obtain neighbors across periodic boundaries.
The vector can be filled by the function GridTools::collect_periodic_faces.
For more information on periodic boundary conditions see GridTools::collect_periodic_faces, DoFTools::make_periodicity_constraints and step45.

inherited 

inherited 

inherited 

inherited 
Write and read the data of this object from a stream for the purpose of serialization. using the BOOST serialization library.

inherited 
Subscribes a user of the object by storing the pointer validity
. The subscriber may be identified by text supplied as identifier
.
Definition at line 136 of file subscriptor.cc.

inherited 
Unsubscribes a user from the object.
identifier
and the validity
pointer must be the same as the one supplied to subscribe(). Definition at line 156 of file subscriptor.cc.

inlineinherited 
Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.
Definition at line 301 of file subscriptor.h.

inlineinherited 
List the subscribers to the input stream
.
Definition at line 318 of file subscriptor.h.

inherited 
List the subscribers to deallog
.
Definition at line 204 of file subscriptor.cc.

private 
Settings
Definition at line 364 of file shared_tria.h.

private 
A flag to decide whether or not artificial cells are allowed.
Definition at line 369 of file shared_tria.h.

private 
A vector containing subdomain IDs of cells obtained by partitioning using either zorder, METIS, or a userdefined partitioning scheme. In case allow_artificial_cells is false, this vector is consistent with IDs stored in cell>subdomain_id() of the triangulation class. When allow_artificial_cells is true, cells which are artificial will have cell>subdomain_id() == numbers::artificial;
The original partition information is stored to allow using sequential DoF distribution and partitioning functions with semiartificial cells.
Definition at line 390 of file shared_tria.h.

private 
A vector containing level subdomain IDs of cells obtained by partitioning each level.
The original partition information is stored to allow using sequential DoF distribution and partitioning functions with semiartificial cells.
Definition at line 401 of file shared_tria.h.

protectedinherited 
MPI communicator to be used for the triangulation. We create a unique communicator for this class, which is a duplicate of the one passed to the constructor.
Definition at line 301 of file tria_base.h.

protectedinherited 
The subdomain id to be used for the current processor. This is the MPI rank.
Definition at line 307 of file tria_base.h.

protectedinherited 
The total number of subdomains (or the size of the MPI communicator).
Definition at line 312 of file tria_base.h.

protectedinherited 
Definition at line 370 of file tria_base.h.

staticinherited 

staticinherited 

mutableinherited 