TriaAccessor< structdim, dim, spacedim > Class Template Reference

Inheritance diagram for TriaAccessor< structdim, dim, spacedim >:

Inheritance graph
[legend]

List of all members.

Public Types

typedef TriaAccessorBase
< structdim, dim, spacedim >
::AccessorData 
AccessorData

Public Member Functions

 TriaAccessor (const Triangulation< dim, spacedim > *parent=0, const int level=-1, const int index=-1, const AccessorData *local_data=0)
template<int structdim2, int dim2, int spacedim2>
 TriaAccessor (const InvalidAccessor< structdim2, dim2, spacedim2 > &)
template<int structdim2, int dim2, int spacedim2>
 TriaAccessor (const TriaAccessor< structdim2, dim2, spacedim2 > &)
bool used () const
Accessing sub-objects
unsigned int vertex_index (const unsigned int i) const
Point< spacedim > & vertex (const unsigned int i) const
internal::Triangulation::Iterators
< dim, spacedim >
::line_iterator 
line (const unsigned int i) const
unsigned int line_index (const unsigned int i) const
internal::Triangulation::Iterators
< dim, spacedim >
::quad_iterator 
quad (const unsigned int i) const
unsigned int quad_index (const unsigned int i) const
Orientation of sub-objects
bool face_orientation (const unsigned int face) const
bool face_flip (const unsigned int face) const
bool face_rotation (const unsigned int face) const
bool line_orientation (const unsigned int line) const
Accessing children
bool has_children () const
unsigned int n_children () const
unsigned int number_of_children () const
unsigned int max_refinement_depth () const
TriaIterator< TriaAccessor
< structdim, dim, spacedim > > 
child (const unsigned int i) const
TriaIterator< TriaAccessor
< structdim, dim, spacedim > > 
isotropic_child (const unsigned int i) const
RefinementCase< structdim > refinement_case () const
int child_index (const unsigned int i) const
int isotropic_child_index (const unsigned int i) const
Dealing with boundary indicators
unsigned char boundary_indicator () const
void set_boundary_indicator (const unsigned char) const
void set_all_boundary_indicators (const unsigned char) const
bool at_boundary () const
User data
bool user_flag_set () const
void set_user_flag () const
void clear_user_flag () const
void recursively_set_user_flag () const
void recursively_clear_user_flag () const
void clear_user_data () const
void set_user_pointer (void *p) const
void clear_user_pointer () const
void * user_pointer () const
void recursively_set_user_pointer (void *p) const
void recursively_clear_user_pointer () const
void set_user_index (const unsigned int p) const
void clear_user_index () const
unsigned int user_index () const
void recursively_set_user_index (const unsigned int p) const
void recursively_clear_user_index () const
Geometric information about an object
double diameter () const
Point< spacedim > center () const
Point< spacedim > barycenter () const
double measure () const

Private Member Functions

void set (const internal::Triangulation::TriaObject< structdim > &o) const
void set_line_orientation (const unsigned int line, const bool orientation) const
void set_face_orientation (const unsigned int face, const bool orientation) const
void set_face_flip (const unsigned int face, const bool flip) const
void set_face_rotation (const unsigned int face, const bool rotation) const
void set_used_flag () const
void clear_used_flag () const
void set_refinement_case (const RefinementCase< structdim > &ref_case) const
void clear_refinement_case () const
void set_children (const unsigned int i, const int index) const
void clear_children () const
void operator= (const TriaAccessor &)

Friends

class Triangulation
class internal::Triangulation::Implementation
class internal::TriaAccessor::Implementation


Detailed Description

template<int structdim, int dim, int spacedim>
class TriaAccessor< structdim, dim, spacedim >

A class that provides access to objects in a triangulation such as its vertices, sub-objects, children, geometric information, etc. This class represents objects of dimension structdim (i.e. 1 for lines, 2 for quads, 3 for hexes) in a triangulation of dimensionality dim (i.e. 1 for a triangulation of lines, 2 for a triangulation of quads, and 3 for a triangulation of hexes) that is embedded in a space of dimensionality spacedim (for spacedim==dim the triangulation represents a domain in $R^{dim}$, for spacedim>dim the triangulation is of a manifold embedded in a higher dimensional space).

Author:
Wolfgang Bangerth and others, 1998, 2000, 2008

Member Typedef Documentation

template<int structdim, int dim, int spacedim>
typedef TriaAccessorBase<structdim,dim,spacedim>::AccessorData TriaAccessor< structdim, dim, spacedim >::AccessorData


Constructor & Destructor Documentation

template<int structdim, int dim, int spacedim>
TriaAccessor< structdim, dim, spacedim >::TriaAccessor ( const Triangulation< dim, spacedim > *  parent = 0,
const int  level = -1,
const int  index = -1,
const AccessorData local_data = 0 
)

Constructor.

template<int structdim, int dim, int spacedim>
template<int structdim2, int dim2, int spacedim2>
TriaAccessor< structdim, dim, spacedim >::TriaAccessor ( const InvalidAccessor< structdim2, dim2, spacedim2 > &   )  [inline]

Conversion constructor. This constructor exists to make certain constructs simpler to write in dimension independent code. For example, it allows assigning a face iterator to a line iterator, an operation that is useful in 2d but doesn't make any sense in 3d. The constructor here exists for the purpose of making the code conform to C++ but it will unconditionally abort; in other words, assigning a face iterator to a line iterator is better put into an if-statement that checks that the dimension is two, and assign to a quad iterator in 3d (an operator that, without this constructor would be illegal if we happen to compile for 2d).

References Assert.

template<int structdim, int dim, int spacedim>
template<int structdim2, int dim2, int spacedim2>
TriaAccessor< structdim, dim, spacedim >::TriaAccessor ( const TriaAccessor< structdim2, dim2, spacedim2 > &   )  [inline]

Another conversion operator between objects that don't make sense, just like the previous one.

References Assert.


Member Function Documentation

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::used (  )  const

Test for the element being used or not. The return value is true for all iterators that are either normal iterators or active iterators, only raw iterators can return false. Since raw iterators are only used in the interiors of the library, you will not usually need this function.

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::vertex_index ( const unsigned int  i  )  const

Return the global index of i-th vertex of the current object. The convention regarding the numbering of vertices is laid down in the documentation of the GeometryInfo class.

Note that the returned value is only the index of the geometrical vertex. It has nothing to do with possible degrees of freedom associated with it. For this, see the DoFAccessor::vertex_dof_index functions.

template<int structdim, int dim, int spacedim>
Point<spacedim>& TriaAccessor< structdim, dim, spacedim >::vertex ( const unsigned int  i  )  const

Return a reference to the ith vertex.

template<int structdim, int dim, int spacedim>
internal::Triangulation::Iterators<dim,spacedim>::line_iterator TriaAccessor< structdim, dim, spacedim >::line ( const unsigned int  i  )  const

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::line_index ( const unsigned int  i  )  const

Line index of the ith line bounding this object.

Implemented only for structdim>1, otherwise an exception generated.

template<int structdim, int dim, int spacedim>
internal::Triangulation::Iterators<dim,spacedim>::quad_iterator TriaAccessor< structdim, dim, spacedim >::quad ( const unsigned int  i  )  const

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::quad_index ( const unsigned int  i  )  const

Quad index of the ith quad bounding this object.

Implemented only for structdim>2, otherwise an exception generated.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::face_orientation ( const unsigned int  face  )  const

Return whether the face with index face has its normal pointing in the standard direction (true) or whether it is the opposite (false). Which is the standard direction is documented with the GeometryInfo class. In 1d and 2d, this is always true, but in 3d it may be different, see the respective discussion in the documentation of the GeometryInfo class.

This function is really only for internal use in the library unless you absolutely know what this is all about.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::face_flip ( const unsigned int  face  )  const

Return whether the face with index face is rotated by 180 degrees (true) or or not (false). In 1d and 2d, this is always false, but in 3d it may be different, see the respective discussion in the documentation of the GeometryInfo class.

This function is really only for internal use in the library unless you absolutely know what this is all about.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::face_rotation ( const unsigned int  face  )  const

Return whether the face with index face is rotated by 90 degrees (true) or or not (false). In 1d and 2d, this is always false, but in 3d it may be different, see the respective discussion in the documentation of the GeometryInfo class.

This function is really only for internal use in the library unless you absolutely know what this is all about.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::line_orientation ( const unsigned int  line  )  const

Return whether the line with index line is oriented in standard direction. true indicates, that the line is oriented from vertex 0 to vertex 1, whereas it is the other way around otherwise. In 1d and 2d, this is always true, but in 3d it may be different, see the respective discussion in the documentation of the GeometryInfo classe.

This function is really only for internal use in the library unless you absolutely know what this is all about.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::has_children (  )  const

Test whether the object has children.

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::n_children (  )  const

Return the number of immediate children of this object. The number of children of an unrefined cell is zero.

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::number_of_children (  )  const

Compute and return the number of active descendants of this objects. For example, if all of the eight children of a hex are further refined isotropically exactly once, the returned number will be 64, not 80.

If the present cell is not refined, one is returned.

If one considers a triangulation as a forest where the root of each tree are the coarse mesh cells and nodes have descendents (the children of a cell), then this function returns the number of terminal nodes in the sub-tree originating from the current object; consequently, if the current object is not further refined, the answer is one.

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::max_refinement_depth (  )  const

Return the number of times that this object is refined. Note that not all its children are refined that often (which is why we prepend max_), the returned number is rather the maximum number of refinement in any branch of children of this object.

For example, if this object is refined, and one of its children is refined exactly one more time, then max_refinement_depth should return 2.

If this object is not refined (i.e. it is active), then the return value is zero.

template<int structdim, int dim, int spacedim>
TriaIterator<TriaAccessor<structdim,dim,spacedim> > TriaAccessor< structdim, dim, spacedim >::child ( const unsigned int  i  )  const

template<int structdim, int dim, int spacedim>
TriaIterator<TriaAccessor<structdim,dim,spacedim> > TriaAccessor< structdim, dim, spacedim >::isotropic_child ( const unsigned int  i  )  const

Return an iterator to that object that is identical to the ith child for isotropic refinement. If the current object is refined isotropically, then the returned object is the ith child. If the current object is refined anisotropically, the returned child may in fact be a grandchild of the object, or may not exist at all (in which case an exception is generated).

template<int structdim, int dim, int spacedim>
RefinementCase<structdim> TriaAccessor< structdim, dim, spacedim >::refinement_case (  )  const

Return the RefinementCase of this cell.

template<int structdim, int dim, int spacedim>
int TriaAccessor< structdim, dim, spacedim >::child_index ( const unsigned int  i  )  const

Index of the ith child. The level of the child is one higher than that of the present cell, if the children of a cell are accessed. The children of faces have no level. If the child does not exist, -1 is returned.

template<int structdim, int dim, int spacedim>
int TriaAccessor< structdim, dim, spacedim >::isotropic_child_index ( const unsigned int  i  )  const

Index of the ith isotropic child. See the isotropic_child() function for a definition of this concept. If the child does not exist, -1 is returned.

template<int structdim, int dim, int spacedim>
unsigned char TriaAccessor< structdim, dim, spacedim >::boundary_indicator (  )  const

Boundary indicator of this object.

If the return value is the special value 255, then this object is in the interior of the domain.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_boundary_indicator ( const unsigned  char  )  const

Set the boundary indicator. The same applies as for the boundary_indicator() function.

Note that it only sets the boundary object of the current object itself, not the indicators of the ones that bound it. For example, in 3d, if this function is called on a face, then the boundary indicator of the 4 edges that bound the face remain unchanged. If you want to set the boundary indicators of face and edges at the same time, use the set_all_boundary_indicators() function.

Warning:
You should never set the boundary indicator of an interior face (a face not at the boundary of the domain), or set set the boundary indicator of an exterior face to 255 (this value is reserved for another purpose). Algorithms may not work or produce very confusing results if boundary cells have a boundary indicator of 255 or if interior cells have boundary indicators other than 255. Unfortunately, the current object has no means of finding out whether it really is at the boundary of the domain and so cannot determine whether the value you are trying to set makes sense under the current circumstances.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_all_boundary_indicators ( const unsigned  char  )  const

Do as set_boundary_indicator() but also set the boundary indicators of the objects that bound the current object. For example, in 3d, if set_boundary_indicator() is called on a face, then the boundary indicator of the 4 edges that bound the face remain unchanged. On the other hand, the boundary indicators of face and edges are all set at the same time using the current function.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::at_boundary (  )  const

Return whether this object is at the boundary. Obviously, the use of this function is only possible for dim>structdim; however, for dim==celldim, an object is a cell and the CellAccessor class offers another possibility to determine whether a cell is at the boundary or not.

Reimplemented in CellAccessor< dim, spacedim >.

template<int structdim, int dim, int spacedim>
bool TriaAccessor< structdim, dim, spacedim >::user_flag_set (  )  const

Read the user flag.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_user_flag (  )  const

Set the user flag.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_user_flag (  )  const

Clear the user flag.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_set_user_flag (  )  const

Set the user flag for this and all descendants.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_clear_user_flag (  )  const

Clear the user flag for this and all descendants.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_user_data (  )  const

Reset the user data to zero, independent if pointer or index.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_user_pointer ( void *  p  )  const

Set the user pointer to p.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_user_pointer (  )  const

Reset the user pointer to a NULL pointer.

template<int structdim, int dim, int spacedim>
void* TriaAccessor< structdim, dim, spacedim >::user_pointer (  )  const

Access the value of the user pointer. It is in the responsibility of the user to make sure that the pointer points to something useful. You should use the new style cast operator to maintain a minimum of typesafety, e.g. A *a=static_cast<A*>(cell->user_pointer());.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_set_user_pointer ( void *  p  )  const

Set the user pointer of this object and all its children to the given value. This is useful for example if all cells of a certain subdomain, or all faces of a certain part of the boundary should have user pointers pointing to objects describing this part of the domain or boundary.

Note that the user pointer is not inherited under mesh refinement, so after mesh refinement there might be cells or faces that don't have user pointers pointing to the describing object. In this case, simply loop over all the elements of the coarsest level that has this information, and use this function to recursively set the user pointer of all finer levels of the triangulation.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_clear_user_pointer (  )  const

Clear the user pointer of this object and all of its descendants. The same holds as said for the recursively_set_user_pointer() function.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_user_index ( const unsigned int  p  )  const

Set the user index to p.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_user_index (  )  const

Reset the user index to 0.

template<int structdim, int dim, int spacedim>
unsigned int TriaAccessor< structdim, dim, spacedim >::user_index (  )  const

Access the value of the user index.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_set_user_index ( const unsigned int  p  )  const

Set the user index of this object and all its children.

Note that the user index is not inherited under mesh refinement, so after mesh refinement there might be cells or faces that don't have the expected user indices. In this case, simply loop over all the elements of the coarsest level that has this information, and use this function to recursively set the user index of all finer levels of the triangulation.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::recursively_clear_user_index (  )  const

Clear the user index of this object and all of its descendants. The same holds as said for the recursively_set_user_index() function.

template<int structdim, int dim, int spacedim>
double TriaAccessor< structdim, dim, spacedim >::diameter (  )  const

Diameter of the object.

The diameter of an object is computed to be the largest diagonal. This is not necessarily the true diameter for objects that may use higher order mappings, but completely sufficient for most computations.

template<int structdim, int dim, int spacedim>
Point<spacedim> TriaAccessor< structdim, dim, spacedim >::center (  )  const

Center of the object. The center of an object is defined to be the average of the locations of the vertices, which is also where the (dim-)linear mapping places the midpoint of the unit cell in real space. However, this may not be the barycenter of the object and it may also not be the true center of an object if higher order mappings are used.

template<int structdim, int dim, int spacedim>
Point<spacedim> TriaAccessor< structdim, dim, spacedim >::barycenter (  )  const

Barycenter of the object.

template<int structdim, int dim, int spacedim>
double TriaAccessor< structdim, dim, spacedim >::measure (  )  const

Volume of the object. Here, the volume is defined to be confined by the (dim-)linear mapping of the unit cell. No information about the actual geometric boundary of the domain is used.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set ( const internal::Triangulation::TriaObject< structdim > &  o  )  const [private]

Copy the data of the given object into the internal data structures of a triangulation.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_line_orientation ( const unsigned int  line,
const bool  orientation 
) const [private]

Set the flag indicating, what line_orientation() will return.

It is only possible to set the line_orientation of faces in 3d (i.e. celldim==2 && dim==3).

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_face_orientation ( const unsigned int  face,
const bool  orientation 
) const [private]

Set whether the quad with index face has its normal pointing in the standard direction (true) or whether it is the opposite (false). Which is the standard direction is documented with the GeometryInfo class.

This function is only for internal use in the library. Setting this flag to any other value than the one that the triangulation has already set is bound to bring you desaster.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_face_flip ( const unsigned int  face,
const bool  flip 
) const [private]

Set the flag indicating, what face_flip() will return.

It is only possible to set the face_orientation of cells in 3d (i.e. celldim==3 && dim==3).

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_face_rotation ( const unsigned int  face,
const bool  rotation 
) const [private]

Set the flag indicating, what face_rotation() will return.

It is only possible to set the face_orientation of cells in 3d (i.e. celldim==3 && dim==3).

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_used_flag (  )  const [private]

Set the used flag. Only for internal use in the library.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_used_flag (  )  const [private]

Clear the used flag. Only for internal use in the library.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_refinement_case ( const RefinementCase< structdim > &  ref_case  )  const [private]

Set the RefinementCase<dim> this TriaObject is refined with. Not defined for celldim=1 as lines are always refined resulting in 2 children lines (isotropic refinement).

You should know quite exactly what you are doing if you touch this function. It is exclusively for internal use in the library.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_refinement_case (  )  const [private]

Clear the RefinementCase<dim> of this TriaObject, i.e. reset it to RefinementCase<dim>::no_refinement.

You should know quite exactly what you are doing if you touch this function. It is exclusively for internal use in the library.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::set_children ( const unsigned int  i,
const int  index 
) const [private]

Set the index of the ith child. Since the children come at least in pairs, we need to store the index of only every second child, i.e. of the even numbered children. Make sure, that the index of child i=0 is set first. Calling this function for odd numbered children is not allowed.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::clear_children (  )  const [private]

Clear the child field, i.e. set it to a value which indicates that this cell has no children.

template<int structdim, int dim, int spacedim>
void TriaAccessor< structdim, dim, spacedim >::operator= ( const TriaAccessor< structdim, dim, spacedim > &   )  [private]

Copy operator. This is normally used in a context like iterator a,b; *a=*b;. Presumably, the intent here is to copy the object pointed to by b to the object pointed to by a. However, the result of dereferencing an iterator is not an object but an accessor; consequently, this operation is not useful for iterators on triangulations. We declare this function here private, thus it may not be used from outside. Furthermore it is not implemented and will give a linker error if used anyway.


Friends And Related Function Documentation

template<int structdim, int dim, int spacedim>
friend class Triangulation [friend]

template<int structdim, int dim, int spacedim>
friend class internal::Triangulation::Implementation [friend]

template<int structdim, int dim, int spacedim>
friend class internal::TriaAccessor::Implementation [friend]


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

deal.II documentation generated on Sat Aug 15 16:52:28 2009 by doxygen 1.5.9