Reference documentation for deal.II version Git 0ec6fa4 2017-05-22 12:08:17 +0200
Classes | Public Types | Public Member Functions | Static Public Attributes | Private Types | List of all members
Triangulation< dim, spacedim > Class Template Reference

#include <deal.II/grid/tria.h>

Inheritance diagram for Triangulation< dim, spacedim >:
[legend]

Classes

struct  CellWeightSum
 
struct  DistortedCellList
 
struct  Signals
 

Public Types

enum  MeshSmoothing {
  none = 0x0, limit_level_difference_at_vertices = 0x1, eliminate_unrefined_islands = 0x2, patch_level_1 = 0x4,
  coarsest_level_1 = 0x8, allow_anisotropic_smoothing = 0x10, eliminate_refined_inner_islands = 0x100, eliminate_refined_boundary_islands = 0x200,
  do_not_produce_unrefined_islands = 0x400, smoothing_on_refinement, smoothing_on_coarsening, maximum_smoothing = 0xffff ^ allow_anisotropic_smoothing
}
 
typedef TriaIterator< CellAccessor< dim, spacedim > > cell_iterator
 
typedef TriaActiveIterator< CellAccessor< dim, spacedim > > active_cell_iterator
 

Public Member Functions

 Triangulation (const MeshSmoothing smooth_grid=none, const bool check_for_distorted_cells=false)
 
 Triangulation (const Triangulation< dim, spacedim > &t)
 
 Triangulation (Triangulation< dim, spacedim > &&tria)
 
Triangulationoperator= (Triangulation< dim, spacedim > &&tria)
 
virtual ~Triangulation ()
 
virtual void clear ()
 
virtual void set_mesh_smoothing (const MeshSmoothing mesh_smoothing)
 
virtual const MeshSmoothingget_mesh_smoothing () const
 
void set_boundary (const types::manifold_id number, const Boundary< dim, spacedim > &boundary_object)
 
void set_boundary (const types::manifold_id number)
 
void set_manifold (const types::manifold_id number, const Manifold< dim, spacedim > &manifold_object)
 
void set_manifold (const types::manifold_id number)
 
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 Boundary< dim, spacedim > & get_boundary (const types::manifold_id number) const
 
const Manifold< dim, spacedim > & get_manifold (const types::manifold_id number) const
 
std::vector< types::boundary_idget_boundary_ids () const
 
std::vector< types::manifold_idget_manifold_ids () const
 
virtual void copy_triangulation (const Triangulation< dim, spacedim > &other_tria)
 
virtual void create_triangulation (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata)
 
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 ()
 
Mesh refinement
void set_all_refine_flags ()
 
void refine_global (const unsigned int times=1)
 
virtual void execute_coarsening_and_refinement ()
 
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 functions returning ranges of iterators
IteratorRange< cell_iteratorcell_iterators () const
 
IteratorRange< active_cell_iteratoractive_cell_iterators () const
 
IteratorRange< cell_iteratorcell_iterators_on_level (const unsigned int level) const
 
IteratorRange< active_cell_iteratoractive_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
 
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
 
virtual types::global_dof_index n_global_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 unsigned int n_global_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
 
virtual types::subdomain_id locally_owned_subdomain () 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 n_raw_hexs (const unsigned int level) const
 
unsigned int n_raw_cells (const unsigned int level) const
 
unsigned int n_raw_faces () const
 
virtual std::size_t memory_consumption () const
 
template<class Archive >
void save (Archive &ar, const unsigned int version) const
 
template<class Archive >
void load (Archive &ar, const unsigned int version)
 
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
 
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 
 Subscriptor (const Subscriptor &)
 
 Subscriptor (Subscriptor &&)
 
virtual ~Subscriptor ()
 
Subscriptoroperator= (const Subscriptor &)
 
Subscriptoroperator= (Subscriptor &&)
 
void subscribe (const char *identifier=nullptr) const
 
void unsubscribe (const char *identifier=nullptr) const
 
unsigned int n_subscriptions () const
 
void list_subscribers () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 

Static Public Attributes

static const StraightBoundary< dim, spacedim > straight_boundary = StraightBoundary<dim,spacedim>()
 
static const unsigned int dimension = dim
 
static const unsigned int space_dimension = spacedim
 

Private Types

typedef ::internal::Triangulation::Iterators< dim, spacedim > IteratorSelector
 

Private Member Functions

Line iterator functions for internal use
raw_line_iterator begin_raw_line (const unsigned int level=0) const
 
line_iterator begin_line (const unsigned int level=0) const
 
active_line_iterator begin_active_line (const unsigned int level=0) const
 
line_iterator end_line () const
 
Quad iterator functions for internal use
raw_quad_iterator begin_raw_quad (const unsigned int level=0) const
 
quad_iterator begin_quad (const unsigned int level=0) const
 
active_quad_iterator begin_active_quad (const unsigned int level=0) const
 
quad_iterator end_quad () const
 

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< GridTools::PeriodicFacePair< cell_iterator > > periodic_face_pairs_level_0
 
std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > periodic_face_map
 
static::ExceptionBase & ExcInvalidLevel (int arg1)
 
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 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)
 
void update_periodic_face_map ()
 

Cell iterator functions for internal use

typedef TriaRawIterator< CellAccessor< dim, spacedim > > raw_cell_iterator
 
typedef TriaRawIterator< TriaAccessor< dim-1, dim, spacedim > > raw_face_iterator
 
typedef IteratorSelector::raw_vertex_iterator raw_vertex_iterator
 
typedef IteratorSelector::raw_line_iterator raw_line_iterator
 
typedef IteratorSelector::raw_quad_iterator raw_quad_iterator
 
typedef IteratorSelector::raw_hex_iterator raw_hex_iterator
 
raw_cell_iterator begin_raw (const unsigned int level=0) const
 
raw_cell_iterator end_raw (const unsigned int level) const
 

Hex iterator functions for internal use

std::vector< std::unique_ptr<::internal::Triangulation::TriaLevel< dim > > > levels
 
std::unique_ptr<::internal::Triangulation::TriaFaces< dim > > faces
 
std::vector< Point< spacedim > > vertices
 
std::vector< bool > vertices_used
 
std::map< types::manifold_id, SmartPointer< const Manifold< dim, spacedim >, Triangulation< dim, spacedim > > > manifold
 
bool anisotropic_refinement
 
const bool check_for_distorted_cells
 
::internal::Triangulation::NumberCache< dim > number_cache
 
std::unique_ptr< std::map< unsigned int, types::boundary_id > > vertex_to_boundary_id_map_1d
 
std::unique_ptr< std::map< unsigned int, types::manifold_id > > vertex_to_manifold_id_map_1d
 
template<int , int , int >
class TriaAccessorBase
 
template<int , int , int >
class TriaAccessor
 
class TriaAccessor< 0, 1, spacedim >
 
class CellAccessor< dim, spacedim >
 
struct ::internal::TriaAccessor::Implementation
 
class hp::DoFHandler< dim, spacedim >
 
struct ::internal::Triangulation::Implementation
 
template<typename >
class ::internal::Triangulation::TriaObjects
 
raw_hex_iterator begin_raw_hex (const unsigned int level=0) const
 
hex_iterator begin_hex (const unsigned int level=0) const
 
active_hex_iterator begin_active_hex (const unsigned int level=0) const
 
hex_iterator end_hex () const
 
void clear_despite_subscriptions ()
 
void reset_active_cell_indices ()
 
DistortedCellList execute_refinement ()
 
void execute_coarsening ()
 
void fix_coarsen_flags ()
 

Additional Inherited Members

- Static Public Member Functions inherited from Subscriptor
static::ExceptionBase & ExcInUse (int arg1, char *arg2, std::string &arg3)
 
static::ExceptionBase & ExcNoSubscriber (char *arg1, char *arg2)
 

Detailed Description

template<int dim, int spacedim = dim>
class Triangulation< dim, spacedim >

Triangulations denote a hierarchy of levels of elements which together form a dim -dimensional manifold in spacedim spatial dimensions (if spacedim is not specified it takes the default value spacedim=dim).

Thus, for example, an object of type Triangulation<1,1> (or simply Triangulation<1> since spacedim==dim by default) is used to represent and handle the usual one-dimensional triangulation used in the finite element method (so, segments on a straight line). On the other hand, objects such as Triangulation<1,2> or Triangulation<2,3> (that are associated with curves in 2D or surfaces in 3D) are the ones one wants to use in the boundary element method.

This class is written to be as independent of the dimension as possible (thus the complex construction of the internal::Triangulation::TriaLevel classes) to allow code-sharing, to allow reducing the need to mirror changes in the code for one dimension to the code for other dimensions. Nonetheless, some of the functions are dependent of the dimension and there only exist specialized versions for distinct dimensions.

This class satisfies the MeshType concept requirements.

Structure and iterators

The actual data structure of a Triangulation object is rather complex and quite inconvenient if one attempted to operate on it directly, since data is spread over quite a lot of arrays and other places. However, there are ways powerful enough to work on these data structures without knowing their exact relations. deal.II uses class local typedefs (see below) to make things as easy and dimension independent as possible.

The Triangulation class provides iterators which enable looping over all cells without knowing the exact representation used to describe them. For more information see the documentation of TriaIterator. Their names are typedefs imported from the Iterators class (thus making them local types to this class) and are as follows:

For dim==1, these iterators are mapped as follows:

typedef line_iterator cell_iterator;
typedef active_line_iterator active_cell_iterator;

while for dim==2 we have the additional face iterator:

typedef quad_iterator cell_iterator;
typedef active_quad_iterator active_cell_iterator;
typedef line_iterator face_iterator;
typedef active_line_iterator active_face_iterator;

By using the cell iterators, you can write code independent of the spatial dimension. The same applies for substructure iterators, where a substructure is defined as a face of a cell. The face of a cell is a vertex in 1D and a line in 2D; however, vertices are handled in a different way and therefore lines have no faces.

The Triangulation class offers functions like begin_active() which gives you an iterator to the first active cell. There are quite a lot of functions returning iterators. Take a look at the class doc to get an overview.

Usage of these iterators is similar to usage of standard container iterators. Some examples taken from the Triangulation source code follow (notice that in the last two examples the template parameter spacedim has been omitted, so it takes the default value dim).

Usage

Usage of a Triangulation is mainly done through the use of iterators. An example probably shows best how to use it:

int main ()
{
// read in a coarse grid file
// we want to log the refinement history
ofstream history ("mesh.history");
// refine first cell
tria.begin_active()->set_refine_flag();
tria.save_refine_flags (history);
// refine first active cell on coarsest level
tria.begin_active()->set_refine_flag ();
tria.save_refine_flags (history);
for (int i=0; i<17; ++i)
{
// refine the presently second last cell 17 times
cell = tria.last_active(tria.n_levels()-1);
--cell;
cell->set_refine_flag ();
tria.save_refine_flags (history);
};
// output the grid
ofstream out("grid.1");
}

Creating a triangulation

There are several possibilities to create a triangulation:

Finally, there is a special function for folks who like bad grids: distort_random(). It moves all the vertices in the grid a bit around by a random value, leaving behind a distorted mesh. Note that you should apply this function to the final mesh, since refinement smoothes the mesh a bit.

The function will make sure that vertices on restricted faces (hanging nodes) will end up in the correct place, i.e. in the middle of the two other vertices of the mother line, and the analogue in higher space dimensions (vertices on the boundary are not corrected, so don't distort boundary vertices in more than two space dimension, i.e. in dimensions where boundary vertices can be hanging nodes). Applying the algorithm has another drawback related to the placement of cells, however: the children of a cell will not occupy the same region of the domain as the mother cell does. While this is the usual behavior with cells at the boundary, here you may get into trouble when using multigrid algorithms or when transferring solutions from coarse to fine grids and back. In general, the use of this function is only safe if you only use the most refined level of the triangulation for computations.

Refinement and coarsening of a triangulation

Refinement of a triangulation may be done through several ways. The most low-level way is directly through iterators: let i be an iterator to an active cell (i.e. the cell pointed to has no children), then the function call i->set_refine_flag() marks the respective cell for refinement. Marking non-active cells results in an error.

After all the cells you wanted to mark for refinement, call execute_coarsening_and_refinement() to actually perform the refinement. This function itself first calls the prepare_coarsening_and_refinement function to regularize the resulting triangulation: since a face between two adjacent cells may only be subdivided once (i.e. the levels of two adjacent cells may differ by one at most; it is not possible to have a cell refined twice while the neighboring one is not refined), some additional cells are flagged for refinement to smooth the grid. This enlarges the number of resulting cells but makes the grid more regular, thus leading to better approximation properties and, above all, making the handling of data structures and algorithms much much easier. To be honest, this is mostly an algorithmic step than one needed by the finite element method.

To coarsen a grid, the same way as above is possible by using i->set_coarsen_flag and calling execute_coarsening_and_refinement().

The reason for first coarsening, then refining is that the refinement usually adds some additional cells to keep the triangulation regular and thus satisfies all refinement requests, while the coarsening does not delete cells not requested for; therefore the refinement will often revert some effects of coarsening while the opposite is not true. The stated order of coarsening before refinement will thus normally lead to a result closer to the intended one.

Marking cells for refinement 'by hand' through iterators is one way to produce a new grid, especially if you know what kind of grid you are looking for, e.g. if you want to have a grid successively refined towards the boundary or always at the center (see the example programs, they do exactly these things). There are more advanced functions, however, which are more suitable for automatic generation of hierarchical grids in the context of a posteriori error estimation and adaptive finite elements. These functions can be found in the GridRefinement class.

Smoothing of a triangulation

Some degradation of approximation properties has been observed for grids which are too unstructured. Therefore, prepare_coarsening_and_refinement() which is automatically called by execute_coarsening_and_refinement() can do some smoothing of the triangulation. Note that mesh smoothing is only done for two or more space dimensions, no smoothing is available at present for one spatial dimension. In the following, let execute_* stand for execute_coarsening_and_refinement().

For the purpose of smoothing, the Triangulation constructor takes an argument specifying whether a smoothing step shall be performed on the grid each time execute_* is called. The default is that such a step not be done, since this results in additional cells being produced, which may not be necessary in all cases. If switched on, calling execute_* results in flagging additional cells for refinement to avoid vertices as the ones mentioned. The algorithms for both regularization and smoothing of triangulations are described below in the section on technical issues. The reason why this parameter must be given to the constructor rather than to execute_* is that it would result in algorithmic problems if you called execute_* once without and once with smoothing, since then in some refinement steps would need to be refined twice.

The parameter taken by the constructor is an integer which may be composed bitwise by the constants defined in the enum MeshSmoothing (see there for the possibilities).

Note
While it is possible to pass all of the flags in MeshSmoothing to objects of type parallel::distributed::Triangulation, it is not always possible to honor all of these smoothing options if they would require knowledge of refinement/coarsening flags on cells not locally owned by this processor. As a consequence, for some of these flags, the ultimate number of cells of the parallel triangulation may depend on the number of processors into which it is partitioned.

Material and boundary information

Each cell, face or edge stores information denoting the material or the part of the boundary that an object belongs to. The material of a cell may be used during matrix generation in order to implement different coefficients in different parts of the domain. It is not used by functions of the grid and dof handling libraries.

This material_id may be set upon construction of a triangulation (through the CellData data structure), or later through use of cell iterators. For a typical use of this functionality, see the step-28 tutorial program. The functions of the GridGenerator namespace typically set the material ID of all cells to zero. When reading a triangulation, the material id must be specified in the input file (UCD format) or is otherwise set to zero. Material IDs are inherited by child cells from their parent upon mesh refinement.

Boundary indicators on lower dimensional objects (these have no material id) indicate the number of a boundary component. These are used for two purposes: First, they specify a boundary curve. When a cell is refined, a function can be used to place new vertices on this curve. See the section on boundary approximation below. Furthermore, the weak formulation of the partial differential equation may have different boundary conditions on different parts of the boundary. The boundary indicator can be used in creating the matrix or the right hand side vector to indicate these different parts of the model (this use is like the material id of cells). Boundary indicators may be in the range from zero to numbers::internal_face_boundary_id-1. The value numbers::internal_face_boundary_id is reserved to denote interior lines (in 2D) and interior lines and quads (in 3D), which do not have a boundary indicator. This way, a program can easily determine, whether such an object is at the boundary or not. Material indicators may be in the range from zero to numbers::invalid_material_id-1.

Lines in two dimensions and quads in three dimensions inherit their boundary indicator to their children upon refinement. You should therefore make sure that if you have different boundary parts, the different parts are separated by a vertex (in 2D) or a line (in 3D) such that each boundary line or quad has a unique boundary indicator.

By default (unless otherwise specified during creation of a triangulation), all parts of the boundary have boundary indicator zero. As a historical wart, this isn't true for 1d meshes, however: For these, leftmost vertices have boundary indicator zero while rightmost vertices have boundary indicator one. In either case, the boundary indicator of a face can be changed using a call of the kind cell->face(1)->set_boundary_id(42);.

See also
Glossary entry on boundary indicators

History of a triangulation

It is possible to reconstruct a grid from its refinement history, which can be stored and loaded through the save_refine_flags and load_refine_flags functions. Normally, the code will look like this:

// open output file
ofstream history("mesh.history");
// do 10 refinement steps
for (unsigned int step=0; step<10; ++step)
{
...;
// flag cells according to some criterion
...;
tria.save_refine_flags (history);
}

If you want to re-create the grid from the stored information, you write:

// open input file
ifstream history("mesh.history");
// do 10 refinement steps
for (unsigned int step=0; step<10; ++step)
{
tria.load_refine_flags (history);
}

The same scheme is employed for coarsening and the coarsening flags.

You may write other information to the output file between different sets of refinement information, as long as you read it upon re-creation of the grid. You should make sure that the other information in the new triangulation which is to be created from the saved flags, matches that of the old triangulation, for example the smoothing level; if not, the cells actually created from the flags may be other ones, since smoothing adds additional cells, but their number may be depending on the smoothing level.

There actually are two sets of save_*_flags and load_*_flags functions. One takes a stream as argument and reads/writes the information from/to the stream, thus enabling storing flags to files. The other set takes an argument of type vector<bool>. This enables the user to temporarily store some flags, e.g. if another function needs them, and restore them afterwards.

User flags and data

A triangulation offers one bit per line, quad, etc for user flags. This field can be accessed as all other data using iterators. Normally, this user flag is used if an algorithm walks over all cells and needs information whether another cell, e.g. a neighbor, has already been processed. See the glossary for more information.

There is another set of user data, which can be either an unsigned int or a void *, for each line, quad, etc. You can access these through the functions listed under User data in the accessor classes. Again, see the glossary for more information.

The value of these user indices or pointers is nullptr by default. Note that the pointers are not inherited to children upon refinement. Still, after a remeshing they are available on all cells, where they were set on the previous mesh.

The usual warning about the missing type safety of void pointers are obviously in place here; responsibility for correctness of types etc lies entirely with the user of the pointer.

Note
User pointers and user indices are stored in the same place. In order to avoid unwanted conversions, Triangulation checks which one of them is in use and does not allow access to the other one, until clear_user_data() has been called.

Boundary approximation

You can specify a boundary function for each boundary component. If a new vertex is created on a side or face at the boundary, this function is used to compute where it will be placed. The boundary indicator of the face will be used to determine the proper component. See Boundary for the details. Usage with the Triangulation object is then like this (let Ball be a class derived from Boundary<2>):

int main ()
{
// set the boundary function
// for all boundaries with
// boundary indicator 0
Ball ball;
tria.set_boundary (0, ball);
// read some coarse grid
for (int i=0; i<8; ++i)
{
cell = tria.begin_active();
endc = tria.end();
// refine all boundary cells
for (; cell!=endc; ++cell)
if (cell->at_boundary())
cell->set_refine_flag();
}
}

You should take note of one caveat: if you have concave boundaries, you must make sure that a new boundary vertex does not lie too much inside the cell which is to be refined. The reason is that the center vertex is placed at the point which is the arithmetic mean of the vertices of the original cell. Therefore if your new boundary vertex is too near the center of the old quadrilateral or hexahedron, the distance to the midpoint vertex will become too small, thus generating distorted cells. This issue is discussed extensively in distorted cells.

Getting notice when a triangulation changes

There are cases where one object would like to know whenever a triangulation is being refined, copied, or modified in a number of other ways. This could of course be achieved if, in your user code, you tell every such object whenever you are about to refine the triangulation, but this will get tedious and is error prone. The Triangulation class implements a more elegant way to achieve this: signals.

In essence, a signal is an object (a member of the Triangulation class) that another object can connect to. A connection is in essence that the connecting object passes a function object taking a certain number and kind of arguments. Whenever the owner of the signal wants to indicate a certain kind of event, it 'triggers' the signal, which in turn means that all connections of the signal are triggered: in other word, the function objects are executed and can take the action that is necessary.

As a simple example, the following code will print something to the output every time the triangulation has just been refined:

void f()
{
std::cout << "Triangulation has been refined." << std::endl;
}
void run ()
{
Triangulation<dim> triangulation;
// fill it somehow
triangulation.signals.post_refinement.connect (&f);
triangulation.refine_global (2);
}

This code will produce output twice, once for each refinement cycle.

A more interesting application would be the following, akin to what the FEValues class does. This class stores a pointer to a triangulation and also an iterator to the cell last handled (so that it can compare the current cell with the previous one and, for example, decide that there is no need to re-compute the Jacobian matrix if the new cell is a simple translation of the previous one). However, whenever the triangulation is modified, the iterator to the previously handled cell needs to be invalidated since it now no longer points to any useful cell (or, at the very least, points to something that may not necessarily resemble the cells previously handled). The code would look something like this (the real code has some more error checking and has to handle the case that subsequent cells might actually belong to different triangulation, but that is of no concern to us here):

template <int dim>
class FEValues
{
Triangulation<dim>::active_cell_iterator current_cell, previous_cell;
public:
void invalidate_previous_cell ();
};
template <int dim>
void
{
if (previous_cell.status() != valid)
{
// previous_cell has not been set. set it now, and register
// with the triangulation that we want to be informed about
// mesh refinement
previous_cell = current_cell;
previous_cell->get_triangulation().signals.post_refinement
std::ref (*this)));
}
else
previous_cell = current_cell;
current_cell = cell;
// ... do something with the cell...
}
template <int dim>
void
{
}

Here, whenever the triangulation is refined, it triggers the post- refinement signal which calls the function object attached to it. This function object is the member function FEValues<dim>::invalidate_previous_cell where we have bound the single argument (the this pointer of a member function that otherwise takes no arguments) to the this pointer of the FEValues object. Note how here there is no need for the code that owns the triangulation and the FEValues object to inform the latter if the former is refined. (In practice, the function would want to connect to some of the other signals that the triangulation offers as well, in particular to creation and deletion signals.)

The Triangulation class has a variety of signals that indicate different actions by which the triangulation can modify itself and potentially require follow-up action elsewhere. Please refer to Triangulation::Signals for details.

Serializing (loading or storing) triangulations

Like many other classes in deal.II, the Triangulation class can stream its contents to an archive using BOOST's serialization facilities. The data so stored can later be retrieved again from the archive to restore the contents of this object. This facility is frequently used to save the state of a program to disk for possible later resurrection, often in the context of checkpoint/restart strategies for long running computations or on computers that aren't very reliable (e.g. on very large clusters where individual nodes occasionally fail and then bring down an entire MPI job).

For technical reasons, writing and restoring a Triangulation object is not trivial. The primary reason is that unlike many other objects, triangulations rely on many other objects to which they store pointers or with which they interface; for example, triangulations store pointers to objects describing boundaries and manifolds, and they have signals that store pointers to other objects so they can be notified of changes in the triangulation (see the section on signals in this introduction). Since these objects are owned by the user space (for example the user can create a custom manifold object), they may not be serializable. So in cases like this, boost::serialize can store a reference to an object instead of the pointer, but the reference will never be satisfied at write time because the object pointed to is not serialized. Clearly, at load time, boost::serialize will not know where to let the pointer point to because it never gets to re-create the object originally pointed to.

For these reasons, saving a triangulation to an archive does not store all information, but only certain parts. More specifically, the information that is stored is everything that defines the mesh such as vertex locations, vertex indices, how vertices are connected to cells, boundary indicators, subdomain ids, material ids, etc. On the other hand, the following information is not stored:

In a sense, this approach to serialization means that re-loading a triangulation is more akin to calling the Triangulation::create_triangulation function and filling it with some additional content, as that function also does not touch the signals and boundary objects that belong to this triangulation. In keeping with this analogy, the Triangulation::load function also triggers the same kinds of signal as Triangulation::create_triangulation.

Technical details

Algorithms for mesh regularization and smoothing upon refinement

We chose an inductive point of view: since upon creation of the triangulation all cells are on the same level, all regularity assumptions regarding the maximum difference in level of cells sharing a common face, edge or vertex hold. Since we use the regularization and smoothing in each step of the mesh history, when coming to the point of refining it further the assumptions also hold.

The regularization and smoothing is done in the prepare_coarsening_and_refinement function, which is called by execute_coarsening_and_refinement at the very beginning. It decides which additional cells to flag for refinement by looking at the old grid and the refinement flags for each cell.

Regularization and smoothing are a bit complementary in that we check whether we need to set additional refinement flags when being on a cell flagged for refinement (regularization) or on a cell not flagged for refinement. This makes readable programming easier.

All the described algorithms apply only for more than one space dimension, since for one dimension no restrictions apply. It may be necessary to apply some smoothing for multigrid algorithms, but this has to be decided upon later.

Warning

It seems impossible to preserve constness of a triangulation through iterator usage. Thus, if you declare pointers to a const triangulation object, you should be well aware that you might involuntarily alter the data stored in the triangulation.

Author
Wolfgang Bangerth, 1998; Ralf Hartmann, 2005

Definition at line 43 of file dof_handler.h.

Member Typedef Documentation

template<int dim, int spacedim = dim>
typedef ::internal::Triangulation::Iterators<dim, spacedim> Triangulation< dim, spacedim >::IteratorSelector
private

An internal typedef to make the definition of the iterator classes simpler.

Definition at line 1249 of file tria.h.

template<int dim, int spacedim = dim>
typedef TriaRawIterator<CellAccessor<dim,spacedim> > Triangulation< dim, spacedim >::raw_cell_iterator
private

Declare a number of iterator types for raw iterators, i.e., iterators that also iterate over holes in the list of cells left by cells that have been coarsened away in previous mesh refinement cycles.

Since users should never have to access these internal properties of how we store data, these iterator types are made private.

Definition at line 3241 of file tria.h.

Constructor & Destructor Documentation

template<int dim, int spacedim>
Triangulation< dim, spacedim >::Triangulation ( const MeshSmoothing  smooth_grid = none,
const bool  check_for_distorted_cells = false 
)

Create an empty triangulation. Do not create any cells.

Parameters
smooth_gridDetermines the level of smoothness of the mesh size function that should be enforced upon mesh refinement.
check_for_distorted_cellsDetermines whether the triangulation should check whether any of the cells that are created by create_triangulation() or execute_coarsening_and_refinement() are distorted (see distorted cells). If set, these two functions may throw an exception if they encounter distorted cells.

Definition at line 8948 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::Triangulation ( const Triangulation< dim, spacedim > &  t)

Copy constructor.

You should really use the copy_triangulation function, so we declare this function but let it throw an internal error. The reason for this is that we may want to use triangulation objects in collections. However, C++ containers require that the objects stored in them are copyable, so we need to provide a copy constructor. On the other hand, copying triangulations is so expensive that we do not want such objects copied by accident, for example in compiler-generated temporary objects. By defining a copy constructor but throwing an error, we satisfy the formal requirements of containers, but at the same time disallow actual copies. Finally, through the exception, one easily finds the places where code has to be changed to avoid copies.

Definition at line 8973 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::Triangulation ( Triangulation< dim, spacedim > &&  tria)

Move constructor.

Create a new triangulation by stealing the internal data of another triangulation.

Definition at line 8992 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::~Triangulation ( )
virtual

Member Function Documentation

template<int dim, int spacedim>
Triangulation< dim, spacedim > & Triangulation< dim, spacedim >::operator= ( Triangulation< dim, spacedim > &&  tria)

Move assignment operator.

Definition at line 9015 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear ( )
virtual

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::distributed::Triangulation< dim, spacedim >, and parallel::distributed::Triangulation< dim >.

Definition at line 9064 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::set_mesh_smoothing ( const MeshSmoothing  mesh_smoothing)
virtual

Set the mesh smoothing to mesh_smoothing. This overrides the MeshSmoothing given to the constructor. It is allowed to call this function only if the triangulation is empty.

Definition at line 9079 of file tria.cc.

template<int dim, int spacedim>
const Triangulation< dim, spacedim >::MeshSmoothing & Triangulation< dim, spacedim >::get_mesh_smoothing ( ) const
virtual

Return the mesh smoothing requirements that are obeyed.

Definition at line 9090 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::copy_triangulation ( const Triangulation< dim, spacedim > &  other_tria)
virtual

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_boundary function and to the Manifold object previously set by the set_manifold() function. You must therefore also guarantee that the boundary and manifold objects 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.

Note
Calling this function triggers the 'copy' signal on other_tria, i.e. the triangulation being copied from. It also triggers the 'create' signal of the current triangulation. See the section on signals in the general documentation for more information.
The list of connections to signals is not copied from the old to the new triangulation since these connections were established to monitor how the old triangulation changes, not how any triangulation it may be copied to changes.

Reimplemented in PersistentTriangulation< dim, spacedim >.

Definition at line 9299 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::create_triangulation ( const std::vector< Point< spacedim > > &  vertices,
const std::vector< CellData< dim > > &  cells,
const SubCellData subcelldata 
)
virtual

Create a triangulation from a list of vertices and a list of cells, each of the latter being a list of 1<<dim vertex indices. The triangulation must be empty upon calling this function and the cell list should be useful (connected domain, etc.).

Material data for the cells is given within the cells array, while boundary information is given in the subcelldata field.

The numbering of vertices within the cells array is subject to some constraints; see the general class documentation for this.

For conditions when this function can generate a valid triangulation, see the documentation of this class, and the GridIn and GridReordering class.

If the check_for_distorted_cells flag was specified upon creation of this object, at the very end of its operation, the current function walks over all cells and verifies that none of the cells is deformed (see the entry on distorted cells in the glossary), where we call a cell deformed if the determinant of the Jacobian of the mapping from reference cell to real cell is negative at least at one of the vertices (this computation is done using the GeometryInfo::jacobian_determinants_at_vertices function). If there are deformed cells, this function throws an exception of kind DistortedCellList. Since this happens after all data structures have been set up, you can catch and ignore this exception if you know what you do – for example, it may be that the determinant is zero (indicating that you have collapsed edges in a cell) but that this is ok because you didn't intend to integrate on this cell anyway. On the other hand, deformed cells are often a sign of a mesh that is too coarse to resolve the geometry of the domain, and in this case ignoring the exception is probably unwise.

Note
This function is used in step-14 .
This function triggers the create signal after doing its work. See the section on signals in the general documentation of this class.
The check for distorted cells is only done if dim==spacedim, as otherwise cells can legitimately be twisted if the manifold they describe is twisted.

Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, PersistentTriangulation< dim, spacedim >, and parallel::shared::Triangulation< dim, spacedim >.

Definition at line 9383 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::create_triangulation_compatibility ( const std::vector< Point< spacedim > > &  vertices,
const std::vector< CellData< dim > > &  cells,
const SubCellData subcelldata 
)
virtual

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

Note
This function internally calls create_triangulation and therefore can throw the same exception as the other function.

Reimplemented in PersistentTriangulation< dim, spacedim >.

Definition at line 9363 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::flip_all_direction_flags ( )

Revert or flip the direction_flags of a dim<spacedim triangulation, see GlossDirectionFlag.

This function throws an exception if dim equals spacedim.

Definition at line 9563 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::set_all_refine_flags ( )

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.

Definition at line 9574 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::refine_global ( const unsigned int  times = 1)

Refine all cells times times, by alternatingly calling set_all_refine_flags and execute_coarsening_and_refinement.

The latter function 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.

Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.

Definition at line 9590 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::execute_coarsening_and_refinement ( )
virtual

Execute both refinement and coarsening of the triangulation.

The function resets all refinement and coarsening flags to false. It uses the user flags for internal purposes. They will therefore be overwritten by undefined content.

To allow user programs to fix up these cells if that is desired, this function after completing all other work may throw an exception of type DistortedCellList that contains a list of those cells that have been refined and have at least one child that is distorted. The function does not create such an exception if no cells have created distorted children. Note that for the check for distorted cells to happen, the check_for_distorted_cells flag has to be specified upon creation of a triangulation object.

See the general docs for more information.

Note
This function triggers the pre- and post-refinement signals before and after doing its work. See the section on signals in the general documentation of this class.
If the boundary description is sufficiently irregular, it can happen that some of the children produced by mesh refinement are distorted (see the extensive discussion on distorted cells).
This function is virtual to allow derived classes to insert hooks, such as saving refinement flags and the like (see e.g. the PersistentTriangulation class).

Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim >, parallel::shared::Triangulation< dim, spacedim >, and PersistentTriangulation< dim, spacedim >.

Definition at line 11881 of file tria.cc.

template<int dim, int spacedim>
bool Triangulation< dim, spacedim >::prepare_coarsening_and_refinement ( )
virtual

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 >, and parallel::distributed::Triangulation< dim >.

Definition at line 12568 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_refine_flags ( std::ostream &  out) const

Save the addresses of the cells which are flagged for refinement to out. For usage, read the general documentation for this class.

Definition at line 9623 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_refine_flags ( std::vector< bool > &  v) const

Same as above, but store the flags to a bitvector rather than to a file.

Definition at line 9606 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_refine_flags ( std::istream &  in)

Read the information stored by save_refine_flags.

Definition at line 9634 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_refine_flags ( const std::vector< bool > &  v)

Read the information stored by save_refine_flags.

Definition at line 9645 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_coarsen_flags ( std::ostream &  out) const

Analogue to save_refine_flags.

Definition at line 9688 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_coarsen_flags ( std::vector< bool > &  v) const

Same as above, but store the flags to a bitvector rather than to a file.

Definition at line 9673 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_coarsen_flags ( std::istream &  out)

Analogue to load_refine_flags.

Definition at line 9699 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_coarsen_flags ( const std::vector< bool > &  v)

Analogue to load_refine_flags.

Definition at line 9710 of file tria.cc.

template<int dim, int spacedim>
bool Triangulation< dim, spacedim >::get_anisotropic_refinement_flag ( ) const

Return whether this triangulation has ever undergone anisotropic (as opposed to only isotropic) refinement.

Definition at line 9728 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_user_flags ( )

Clear all user flags. See also GlossUserFlags.

Definition at line 9871 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags ( std::ostream &  out) const

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.

Definition at line 9881 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags ( std::vector< bool > &  v) const

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.

Definition at line 9898 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags ( std::istream &  in)

Read the information stored by save_user_flags. See also GlossUserFlags.

Definition at line 9928 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags ( const std::vector< bool > &  v)

Read the information stored by save_user_flags. See also GlossUserFlags.

Definition at line 9945 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_user_flags_line ( )

Clear all user flags on lines. See also GlossUserFlags.

Definition at line 9799 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_line ( std::ostream &  out) const

Save the user flags on lines. See also GlossUserFlags.

Definition at line 9995 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_line ( std::vector< bool > &  v) const

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.

Definition at line 9980 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_line ( std::istream &  in)

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

Definition at line 10006 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_line ( const std::vector< bool > &  v)

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

Definition at line 10017 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_user_flags_quad ( )

Clear all user flags on quads. See also GlossUserFlags.

Definition at line 9831 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_quad ( std::ostream &  out) const

Save the user flags on quads. See also GlossUserFlags.

Definition at line 10105 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_quad ( std::vector< bool > &  v) const

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.

Definition at line 10086 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_quad ( std::istream &  in)

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

Definition at line 10116 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_quad ( const std::vector< bool > &  v)

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

Definition at line 10127 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_user_flags_hex ( )

Clear all user flags on quads. See also GlossUserFlags.

Definition at line 9863 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_hex ( std::ostream &  out) const

Save the user flags on hexs. See also GlossUserFlags.

Definition at line 10168 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_flags_hex ( std::vector< bool > &  v) const

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.

Definition at line 10149 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_hex ( std::istream &  in)

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

Definition at line 10179 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_flags_hex ( const std::vector< bool > &  v)

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

Definition at line 10190 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_user_data ( )

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

Definition at line 9771 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_indices ( std::vector< unsigned int > &  v) const

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

Definition at line 10212 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_indices ( const std::vector< unsigned int > &  v)

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

Definition at line 10242 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_pointers ( std::vector< void * > &  v) const

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

Definition at line 10447 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_pointers ( const std::vector< void * > &  v)

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

Definition at line 10477 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_indices_line ( std::vector< unsigned int > &  v) const

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

Definition at line 10314 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_indices_line ( const std::vector< unsigned int > &  v)

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

Definition at line 10327 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_indices_quad ( std::vector< unsigned int > &  v) const

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

Definition at line 10340 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_indices_quad ( const std::vector< unsigned int > &  v)

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

Definition at line 10357 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_indices_hex ( std::vector< unsigned int > &  v) const

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

Definition at line 10373 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_indices_hex ( const std::vector< unsigned int > &  v)

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

Definition at line 10390 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_pointers_line ( std::vector< void * > &  v) const

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

Definition at line 10512 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_pointers_line ( const std::vector< void * > &  v)

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

Definition at line 10525 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_pointers_quad ( std::vector< void * > &  v) const

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

Definition at line 10539 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_pointers_quad ( const std::vector< void * > &  v)

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

Definition at line 10556 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save_user_pointers_hex ( std::vector< void * > &  v) const

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

Definition at line 10572 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load_user_pointers_hex ( const std::vector< void * > &  v)

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

Definition at line 10589 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::cell_iterator Triangulation< dim, spacedim >::begin ( const unsigned int  level = 0) const

Iterator to the first used cell on level level.

Definition at line 10630 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_cell_iterator Triangulation< dim, spacedim >::begin_active ( const unsigned int  level = 0) const

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

for (cell=tria.begin_active(level); cell!=tria.end_active(level); ++cell)
...

have zero iterations, as may be expected if there are no active cells on this level.

Definition at line 10650 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::cell_iterator Triangulation< dim, spacedim >::end ( ) const

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

Definition at line 10718 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::cell_iterator Triangulation< dim, spacedim >::end ( const unsigned int  level) const

Return an iterator which is the first iterator not on level. If level is the last level, then this returns end().

Definition at line 10741 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_cell_iterator Triangulation< dim, spacedim >::end_active ( const unsigned int  level) const

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

Definition at line 10752 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::cell_iterator Triangulation< dim, spacedim >::last ( ) const

Return an iterator pointing to the last used cell.

Definition at line 10670 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_cell_iterator Triangulation< dim, spacedim >::last_active ( ) const

Return an iterator pointing to the last active cell.

Definition at line 10697 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::face_iterator Triangulation< dim, spacedim >::begin_face ( ) const

Iterator to the first used face.

Definition at line 10809 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_face_iterator Triangulation< dim, spacedim >::begin_active_face ( ) const

Iterator to the first active face.

Definition at line 10830 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::face_iterator Triangulation< dim, spacedim >::end_face ( ) const

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

Definition at line 10851 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::vertex_iterator Triangulation< dim, spacedim >::begin_vertex ( ) const

Iterator to the first used vertex. This function can only be used if dim is not one.

Definition at line 10874 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_vertex_iterator Triangulation< dim, spacedim >::begin_active_vertex ( ) const

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.

Definition at line 10902 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::vertex_iterator Triangulation< dim, spacedim >::end_vertex ( ) const

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states. This function can only be used if dim is not one.

Definition at line 10911 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_lines ( ) const

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.

Definition at line 11359 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_lines ( const unsigned int  level) const

Return the total number of used lines, active or not on level level.

Definition at line 11431 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_lines ( ) const

Return the total number of active lines.

Definition at line 11441 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_lines ( const unsigned int  level) const

Return the total number of active lines, on level level.

Definition at line 11448 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_quads ( ) const

Return the total number of used quads, active or not.

Definition at line 11588 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_quads ( const unsigned int  level) const

Return the total number of used quads, active or not on level level.

Definition at line 11595 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_quads ( ) const

Return the total number of active quads, active or not.

Definition at line 11651 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_quads ( const unsigned int  level) const

Return the total number of active quads, active or not on level level.

Definition at line 11658 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_hexs ( ) const

Return the total number of used hexahedra, active or not.

Definition at line 11669 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_hexs ( const unsigned int  level) const

Return the total number of used hexahedra, active or not on level level.

Definition at line 11677 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_hexs ( ) const

Return the total number of active hexahedra, active or not.

Definition at line 11692 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_hexs ( const unsigned int  level) const

Return the total number of active hexahedra, active or not on level level.

Definition at line 11700 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_cells ( ) const

Return the total number of used cells, active or not. Maps to n_lines() in one space dimension and so on.

Definition at line 11219 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_cells ( const unsigned int  level) const

Return the total number of used cells, active or not, on level level. Maps to n_lines(level) in one space dimension and so on.

Definition at line 11311 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_cells ( ) const

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

Definition at line 11226 of file tria.cc.

template<int dim, int spacedim>
types::global_dof_index Triangulation< dim, spacedim >::n_global_active_cells ( ) const
virtual

Return the total number of active cells. For the current class, this is the same as n_active_cells(). However, the function may be overloaded in derived classes (e.g., in parallel::distributed::Triangulation) where it may return a value greater than the number of active cells reported by the triangulation object on the current processor.

Reimplemented in parallel::Triangulation< dim, spacedim >, and parallel::Triangulation< 1, spacedim >.

Definition at line 11232 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_cells ( const unsigned int  level) const

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

Definition at line 11330 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_faces ( ) const

Return the total number of used faces, active or not. In 2D, the result equals n_lines(), while in 3D it equals n_quads(). Since there are no face objects in 1d, the function returns zero in 1d.

Definition at line 11240 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_active_faces ( ) const

Return the total number of active faces, active or not. In 2D, the result equals n_active_lines(), while in 3D it equals n_active_quads(). Since there are no face objects in 1d, the function returns zero in 1d.

Definition at line 11274 of file tria.cc.

template<int dim, int spacedim = dim>
unsigned int Triangulation< dim, spacedim >::n_levels ( ) const

Return the number of levels in this triangulation.

Note
Internally, triangulations store data in levels, and there may be more levels in this data structure than one may think – for example, imagine a triangulation that we just got by coarsening the highest level so that it was completely depopulated. That level is not removed, since it will most likely be repopulated soon by the next refinement process. As a consequence, if you happened to run through raw cell iterators (which you can't do as a user of this class, but can internally), then the number of objects in the levels hierarchy is larger than the level of the most refined cell plus one. On the other hand, since this is rarely what a user of this class cares about, the function really just returns the level of the most refined active cell plus one. (The plus one is because in a coarse, unrefined mesh, all cells have level zero – making the number of levels equal to one.)
template<int dim, int spacedim = dim>
virtual unsigned int Triangulation< dim, spacedim >::n_global_levels ( ) const
virtual

Return the number of levels in use. This function is equivalent to n_levels() for a serial Triangulation, but gives the maximum of n_levels() over all processors for a parallel::distributed::Triangulation and therefore can be larger than n_levels().

Reimplemented in parallel::Triangulation< dim, spacedim >, and parallel::Triangulation< 1, spacedim >.

template<int dim, int spacedim>
bool Triangulation< dim, spacedim >::has_hanging_nodes ( ) const
virtual

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 >, and parallel::distributed::Triangulation< dim >.

Definition at line 11348 of file tria.cc.

template<int dim, int spacedim = dim>
unsigned int Triangulation< dim, spacedim >::n_vertices ( ) const

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.

template<int dim, int spacedim = dim>
const std::vector<Point<spacedim> >& Triangulation< dim, spacedim >::get_vertices ( ) const

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

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_used_vertices ( ) const

Return the number of vertices that are presently in use, i.e. belong to at least one used element.

Definition at line 11754 of file tria.cc.

template<int dim, int spacedim = dim>
bool Triangulation< dim, spacedim >::vertex_used ( const unsigned int  index) const

Return true if the vertex with this index is used.

template<int dim, int spacedim>
const std::vector< bool > & Triangulation< dim, spacedim >::get_used_vertices ( ) const

Return a constant reference to the array of bools indicating whether an entry in the vertex array is used or not.

Definition at line 11764 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::max_adjacent_cells ( ) const

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.

Definition at line 11795 of file tria.cc.

template<int dim, int spacedim>
types::subdomain_id Triangulation< dim, spacedim >::locally_owned_subdomain ( ) const
virtual

This function always returns invalid_subdomain_id but is there for compatibility with the derived parallel::distributed::Triangulation class. For distributed parallel triangulations this function returns the subdomain id of those cells that are owned by the current processor.

Reimplemented in parallel::Triangulation< dim, spacedim >, and parallel::Triangulation< 1, spacedim >.

Definition at line 11828 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim > & Triangulation< dim, spacedim >::get_triangulation ( )

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

Definition at line 11837 of file tria.cc.

template<int dim, int spacedim>
const Triangulation< dim, spacedim > & Triangulation< dim, spacedim >::get_triangulation ( ) const

Return a reference to the current object. This is the const-version of the previous function.

Definition at line 11846 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_lines ( ) const

Total number of lines, used or unused.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11424 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_lines ( const unsigned int  level) const

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

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11416 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_quads ( ) const

Total number of quads, used or unused.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11634 of file tria.cc.

template<int dim, int spacedim = dim>
unsigned int Triangulation< dim, spacedim >::n_raw_quads ( const unsigned int  level) const

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

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).
template<int dim, int spacedim = dim>
unsigned int Triangulation< dim, spacedim >::n_raw_hexs ( ) const

Total number of hexs, used or unused.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).
template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_hexs ( const unsigned int  level) const

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

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11685 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_cells ( const unsigned int  level) const

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

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11292 of file tria.cc.

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::n_raw_faces ( ) const

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

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

Definition at line 11258 of file tria.cc.

template<int dim, int spacedim>
std::size_t Triangulation< dim, spacedim >::memory_consumption ( ) const
virtual

Determine an estimate for the memory consumption (in bytes) of this object.

This function is made virtual, since a triangulation object might be accessed through a pointer to this base class, even if the actual object is a derived class.

Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim >, PersistentTriangulation< dim, spacedim >, parallel::Triangulation< dim, spacedim >, and parallel::Triangulation< 1, spacedim >.

Definition at line 13531 of file tria.cc.

template<int dim, int spacedim = dim>
template<class Archive >
void Triangulation< dim, spacedim >::save ( Archive &  ar,
const unsigned int  version 
) const

Write the data of this object to a stream for the purpose of serialization.

Note
This function does not save all member variables of the current triangulation. Rather, only certain kinds of information are stored. For more information see the general documentation of this class.
template<int dim, int spacedim = dim>
template<class Archive >
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.

Note
This function does not reset all member variables of the current triangulation to the ones of the triangulation that was previously stored to an archive. Rather, only certain kinds of information are loaded. For more information see the general documentation of this class.
This function calls the Triangulation::clear() function and consequently triggers the "clear" signal. After loading all data from the archive, it then triggers the "create" signal. For more information on signals, see the general documentation of this class.
template<int dim, int spacedim>
void Triangulation< dim, spacedim >::add_periodicity ( const std::vector< GridTools::PeriodicFacePair< cell_iterator > > &  periodicity_vector)
virtual

Declare the (coarse) face pairs given in the argument of this function as periodic. This way it it 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 step-45.

Note
Before this function can be used the Triangulation has to be initialized and must not be refined.

Reimplemented in parallel::distributed::Triangulation< dim >.

Definition at line 11856 of file tria.cc.

template<int dim, int spacedim>
const std::map< std::pair< typename Triangulation< dim, spacedim >::cell_iterator, unsigned int >, std::pair< std::pair< typename Triangulation< dim, spacedim >::cell_iterator, unsigned int >, std::bitset< 3 > > > & Triangulation< dim, spacedim >::get_periodic_face_map ( ) const

Return the periodic_face_map.

Definition at line 11872 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::write_bool_vector ( const unsigned int  magic_number1,
const std::vector< bool > &  v,
const unsigned int  magic_number2,
std::ostream &  out 
)
staticprotected

Write a bool vector to the given stream, writing a pre- and a postfix magic number. The vector is written in an almost binary format, i.e. the bool flags are packed but the data is written as ASCII text.

The flags are stored in a binary format: for each true, a 1 bit is stored, a 0 bit otherwise. The bits are stored as unsigned char, thus avoiding endianess. They are written to out in plain text, thus amounting to 3.6 bits in the output per bits in the input on the average. Other information (magic numbers and number of elements of the input vector) is stored as plain text as well. The format should therefore be interplatform compatible.

Definition at line 13461 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::read_bool_vector ( const unsigned int  magic_number1,
std::vector< bool > &  v,
const unsigned int  magic_number2,
std::istream &  in 
)
staticprotected

Re-read a vector of bools previously written by write_bool_vector and compare with the magic numbers.

Definition at line 13493 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::update_periodic_face_map ( )
protected

Recreate information about periodic neighbors from periodic_face_pairs_level_0.

Definition at line 11943 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::raw_cell_iterator Triangulation< dim, spacedim >::begin_raw ( const unsigned int  level = 0) const
private

Iterator to the first cell, used or not, on level level. If a level has no cells, a past-the-end iterator is returned.

Definition at line 10610 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::raw_cell_iterator Triangulation< dim, spacedim >::end_raw ( const unsigned int  level) const
private

Return a raw iterator which is the first iterator not on level. If level is the last level, then this returns end().

Definition at line 10729 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::raw_line_iterator Triangulation< dim, spacedim >::begin_raw_line ( const unsigned int  level = 0) const
private

Iterator to the first line, used or not, on level level. If a level has no lines, a past-the-end iterator is returned. If lines are no cells, i.e. for dim>1 no level argument must be given. The same applies for all the other functions above, of course.

Definition at line 10933 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::line_iterator Triangulation< dim, spacedim >::begin_line ( const unsigned int  level = 0) const
private

Iterator to the first used line on level level.

Definition at line 10958 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_line_iterator Triangulation< dim, spacedim >::begin_active_line ( const unsigned int  level = 0) const
private

Iterator to the first active line on level level.

Definition at line 10974 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::line_iterator Triangulation< dim, spacedim >::end_line ( ) const
private

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

Definition at line 10990 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::raw_quad_iterator Triangulation< dim, spacedim >::begin_raw_quad ( const unsigned int  level = 0) const
private

Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for \(dim>2\) no level argument must be given.

Definition at line 11004 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::quad_iterator Triangulation< dim, spacedim >::begin_quad ( const unsigned int  level = 0) const
private

Iterator to the first used quad on level level.

Definition at line 11043 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_quad_iterator Triangulation< dim, spacedim >::begin_active_quad ( const unsigned int  level = 0) const
private

Iterator to the first active quad on level level.

Definition at line 11059 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::quad_iterator Triangulation< dim, spacedim >::end_quad ( ) const
private

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

Definition at line 11075 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::raw_hex_iterator Triangulation< dim, spacedim >::begin_raw_hex ( const unsigned int  level = 0) const
private

Iterator to the first hex, used or not, on level level. If a level has no hexs, a past-the-end iterator is returned.

Definition at line 11088 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::hex_iterator Triangulation< dim, spacedim >::begin_hex ( const unsigned int  level = 0) const
private

Iterator to the first used hex on level level.

Definition at line 11118 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::active_hex_iterator Triangulation< dim, spacedim >::begin_active_hex ( const unsigned int  level = 0) const
private

Iterator to the first active hex on level level.

Definition at line 11134 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::hex_iterator Triangulation< dim, spacedim >::end_hex ( ) const
private

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

Definition at line 11150 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::clear_despite_subscriptions ( )
private

The (public) function clear() will only work when the triangulation is not subscribed to by other users. The clear_despite_subscriptions() function now allows the triangulation being cleared even when there are subscriptions.

Make sure, you know what you do, when calling this function, as its use is reasonable in very rare cases, only. For example, when the subscriptions were for the initially empty Triangulation and the Triangulation object wants to release its memory before throwing an assertion due to input errors (e.g. in the create_triangulation() function).

Definition at line 11992 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::reset_active_cell_indices ( )
private

For all cells, set the active cell indices so that active cells know the how many-th active cell they are, and all other cells have an invalid value. This function is called after mesh creation, refinement, and serialization.

Definition at line 11925 of file tria.cc.

template<int dim, int spacedim>
Triangulation< dim, spacedim >::DistortedCellList Triangulation< dim, spacedim >::execute_refinement ( )
private

Refine all cells on all levels which were previously flagged for refinement.

Note, that this function uses the line->user_flags for dim=2,3 and the quad->user_flags for dim=3.

The function returns a list of cells that have produced children that satisfy the criteria of distorted cells if the check_for_distorted_cells flag was specified upon creation of this object, at

Definition at line 12008 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::execute_coarsening ( )
private

Coarsen all cells which were flagged for coarsening, or rather: delete all children of those cells of which all child cells are flagged for coarsening and several other constraints hold (see the general doc of this class).

Definition at line 12042 of file tria.cc.

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::fix_coarsen_flags ( )
private

Make sure that either all or none of the children of a cell are tagged for coarsening.

Definition at line 12114 of file tria.cc.

Member Data Documentation

template<int dim, int spacedim = dim>
const StraightBoundary< dim, spacedim > Triangulation< dim, spacedim >::straight_boundary = StraightBoundary<dim,spacedim>()
static

Default manifold object. This is used for those objects for which no boundary description has been explicitly set using set_manifold().

Definition at line 1256 of file tria.h.

template<int dim, int spacedim = dim>
const unsigned int Triangulation< dim, spacedim >::dimension = dim
static

Make the dimension available in function templates.

Definition at line 1551 of file tria.h.

template<int dim, int spacedim = dim>
const unsigned int Triangulation< dim, spacedim >::space_dimension = spacedim
static

Make the space-dimension available in function templates.

Definition at line 1556 of file tria.h.

template<int dim, int spacedim = dim>
MeshSmoothing Triangulation< dim, spacedim >::smooth_grid
protected

Do some smoothing in the process of refining the triangulation. See the general doc of this class for more information about this.

Definition at line 3179 of file tria.h.

template<int dim, int spacedim = dim>
std::vector<GridTools::PeriodicFacePair<cell_iterator> > Triangulation< dim, spacedim >::periodic_face_pairs_level_0
private

If add_periodicity() is called, this variable stores the given periodic face pairs on level 0 for later access during the identification of ghost cells for the multigrid hierarchy and for setting up the periodic_face_map.

Definition at line 3221 of file tria.h.

template<int dim, int spacedim = dim>
std::map<std::pair<cell_iterator, unsigned int>, std::pair<std::pair<cell_iterator, unsigned int>, std::bitset<3> > > Triangulation< dim, spacedim >::periodic_face_map
private

If add_periodicity() is called, this variable stores the active periodic face pairs.

Definition at line 3226 of file tria.h.

template<int dim, int spacedim = dim>
std::vector<std::unique_ptr<::internal::Triangulation::TriaLevel<dim> > > Triangulation< dim, spacedim >::levels
private

Array of pointers pointing to the objects storing the cell data on the different levels.

Definition at line 3428 of file tria.h.

template<int dim, int spacedim = dim>
std::unique_ptr<::internal::Triangulation::TriaFaces<dim> > Triangulation< dim, spacedim >::faces
private

Pointer to the faces of the triangulation. In 1d this contains nothing, in 2D it contains data concerning lines and in 3D quads and lines. All of these have no level and are therefore treated separately.

Definition at line 3435 of file tria.h.

template<int dim, int spacedim = dim>
std::vector<Point<spacedim> > Triangulation< dim, spacedim >::vertices
private

Array of the vertices of this triangulation.

Definition at line 3441 of file tria.h.

template<int dim, int spacedim = dim>
std::vector<bool> Triangulation< dim, spacedim >::vertices_used
private

Array storing a bit-pattern which vertices are used.

Definition at line 3446 of file tria.h.

template<int dim, int spacedim = dim>
std::map<types::manifold_id, SmartPointer<const Manifold<dim,spacedim> , Triangulation<dim, spacedim> > > Triangulation< dim, spacedim >::manifold
private

Collection of manifold objects. We store only objects, which are not of type FlatManifold.

Definition at line 3452 of file tria.h.

template<int dim, int spacedim = dim>
bool Triangulation< dim, spacedim >::anisotropic_refinement
private

Flag indicating whether anisotropic refinement took place.

Definition at line 3458 of file tria.h.

template<int dim, int spacedim = dim>
const bool Triangulation< dim, spacedim >::check_for_distorted_cells
private

A flag that determines whether we are to check for distorted cells upon creation and refinement of a mesh.

Definition at line 3465 of file tria.h.

template<int dim, int spacedim = dim>
::internal::Triangulation::NumberCache<dim> Triangulation< dim, spacedim >::number_cache
private

Cache to hold the numbers of lines, quads, hexes, etc. These numbers are set at the end of the refinement and coarsening functions and enable faster access later on. In the old days, whenever one wanted to access one of these numbers, one had to perform a loop over all lines, e.g., and count the elements until we hit the end iterator. This is time consuming and since access to the number of lines etc is a rather frequent operation, this was not an optimal solution.

Definition at line 3476 of file tria.h.

template<int dim, int spacedim = dim>
std::unique_ptr<std::map<unsigned int, types::boundary_id> > Triangulation< dim, spacedim >::vertex_to_boundary_id_map_1d
private

A map that relates the number of a boundary vertex to the boundary indicator. This field is only used in 1d. We have this field because we store boundary indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.

The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_boundary_id) were not a pointer.

Definition at line 3492 of file tria.h.

template<int dim, int spacedim = dim>
std::unique_ptr<std::map<unsigned int, types::manifold_id> > Triangulation< dim, spacedim >::vertex_to_manifold_id_map_1d
private

A map that relates the number of a boundary vertex to the manifold indicator. This field is only used in 1d. We have this field because we store manifold indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.

Note
Manifold objects are pretty useless for points since they are neither refined nor are their interiors mapped. We nevertheless allow storing manifold ids for points to be consistent in dimension-independent programs.

The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_boundary_id) were not a pointer.

Definition at line 3514 of file tria.h.


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