Reference documentation for deal.II version 9.4.1
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Friends | List of all members
DoFAccessor< 0, 1, spacedim, level_dof_access > Class Template Reference

#include <deal.II/dofs/dof_accessor.h>

Inheritance diagram for DoFAccessor< 0, 1, spacedim, level_dof_access >:
[legend]

Public Types

using BaseClass = TriaAccessor< 0, 1, spacedim >
 
using AccessorData = DoFHandler< 1, spacedim >
 
enum  VertexKind { left_vertex , interior_vertex , right_vertex }
 

Public Member Functions

const DoFHandler< 1, spacedim > & get_dof_handler () const
 
template<bool level_dof_access2>
void copy_from (const DoFAccessor< 0, 1, spacedim, level_dof_access2 > &a)
 
void copy_from (const TriaAccessorBase< 0, 1, spacedim > &da)
 
void copy_from (const TriaAccessor &)
 
int index () const
 
const Triangulation< 1, spacedim > & get_triangulation () const
 
bool at_boundary () const
 
types::boundary_id boundary_id () const
 
const Manifold< 1, spacedim > & get_manifold () const
 
types::manifold_id manifold_id () const
 
bool used () const
 
ReferenceCell reference_cell () const
 
unsigned int n_vertices () const
 
unsigned int n_lines () const
 
std_cxx20::ranges::iota_view< unsigned int, unsigned intvertex_indices () const
 
std_cxx20::ranges::iota_view< unsigned int, unsigned intline_indices () const
 
Constructors
 DoFAccessor ()
 
 DoFAccessor (const Triangulation< 1, spacedim > *tria, const typename TriaAccessor< 0, 1, spacedim >::VertexKind vertex_kind, const unsigned int vertex_index, const DoFHandler< 1, spacedim > *dof_handler)
 
 DoFAccessor (const Triangulation< 1, spacedim > *, const int=0, const int=0, const DoFHandler< 1, spacedim > *dof_handler=0)
 
template<int structdim2, int dim2, int spacedim2>
 DoFAccessor (const InvalidAccessor< structdim2, dim2, spacedim2 > &)
 
template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
 DoFAccessor (const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &)
 
 DoFAccessor (const DoFAccessor< 0, 1, spacedim, level_dof_access > &)=default
 
 DoFAccessor (DoFAccessor< 0, 1, spacedim, level_dof_access > &&)=default
 
 ~DoFAccessor ()=default
 
DoFAccessor< 0, 1, spacedim, level_dof_access > & operator= (const DoFAccessor< 0, 1, spacedim, level_dof_access > &da)=delete
 
DoFAccessor< 0, 1, spacedim, level_dof_access > & operator= (DoFAccessor< 0, 1, spacedim, level_dof_access > &&) noexcept=default
 
Accessing sub-objects
TriaIterator< DoFAccessor< 0, 1, spacedim, level_dof_access > > child (const unsigned int c) const
 
typename::internal::DoFHandlerImplementation::Iterators< 1, spacedim, level_dof_access >::line_iterator line (const unsigned int i) const
 
typename::internal::DoFHandlerImplementation::Iterators< 1, spacedim, level_dof_access >::quad_iterator quad (const unsigned int i) const
 
Accessing the DoF indices of this object
void get_dof_indices (std::vector< types::global_dof_index > &dof_indices, const unsigned int fe_index=AccessorData::invalid_fe_index) const
 
void get_mg_dof_indices (const int level, std::vector< types::global_dof_index > &dof_indices, const unsigned int fe_index=AccessorData::invalid_fe_index) const
 
types::global_dof_index vertex_dof_index (const unsigned int vertex, const unsigned int i, const unsigned int fe_index=AccessorData::invalid_fe_index) const
 
types::global_dof_index dof_index (const unsigned int i, const unsigned int fe_index=AccessorData::invalid_fe_index) const
 
Accessing the finite element associated with this object
unsigned int n_active_fe_indices () const
 
unsigned int nth_active_fe_index (const unsigned int n) const
 
bool fe_index_is_active (const unsigned int fe_index) const
 
const FiniteElement< 1, spacedim > & get_fe (const unsigned int fe_index) const
 
Advancement of iterators
void operator++ () const
 
void operator-- () const
 
bool operator== (const TriaAccessor &) const
 
bool operator!= (const TriaAccessor &) const
 
bool operator< (const TriaAccessor &other) 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
 
Dealing with boundary indicators
void set_boundary_id (const types::boundary_id) const
 
void set_manifold_id (const types::manifold_id)
 
void set_all_boundary_ids (const types::boundary_id) const
 
void set_all_manifold_ids (const types::manifold_id)
 

Static Public Member Functions

static ::ExceptionBaseExcInvalidObject ()
 
static ::ExceptionBaseExcVectorNotEmpty ()
 
static ::ExceptionBaseExcVectorDoesNotMatch ()
 
static ::ExceptionBaseExcMatrixDoesNotMatch ()
 
static ::ExceptionBaseExcNotActive ()
 
static ::ExceptionBaseExcCantCompareIterators ()
 
static IteratorState::IteratorStates state ()
 
static int level ()
 
Orientation of sub-objects
static unsigned char combined_face_orientation (const unsigned int face)
 Always return 0. More...
 
static bool face_orientation (const unsigned int face)
 Always return false. More...
 
static bool face_flip (const unsigned int face)
 Always return false. More...
 
static bool face_rotation (const unsigned int face)
 Always return false. More...
 
static bool line_orientation (const unsigned int line)
 Always return false. More...
 
Accessing children
static bool has_children ()
 
static unsigned int n_children ()
 
static unsigned int n_active_descendants ()
 
static unsigned int number_of_children ()
 
static unsigned int max_refinement_depth ()
 
static unsigned int child_iterator_to_index (const TriaIterator< TriaAccessor< 0, 1, spacedim > > &)
 Return an invalid unsigned integer. More...
 
static TriaIterator< TriaAccessor< 0, 1, spacedim > > child (const unsigned int)
 Return an invalid object. More...
 
static TriaIterator< TriaAccessor< 0, 1, spacedim > > isotropic_child (const unsigned int)
 Return an invalid object. More...
 
static RefinementCase< 0 > refinement_case ()
 
static int child_index (const unsigned int i)
 Returns -1. More...
 
static int isotropic_child_index (const unsigned int i)
 Returns -1. More...
 

Static Public Attributes

static constexpr unsigned int dimension = 1
 
static constexpr unsigned int space_dimension = spacedim
 
static const unsigned int structure_dimension = 0
 

Protected Member Functions

template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
bool operator== (const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &) const
 
template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
bool operator!= (const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &) const
 
void set_dof_handler (DoFHandler< 1, spacedim > *dh)
 
void set_dof_index (const unsigned int i, const types::global_dof_index index, const unsigned int fe_index=AccessorData::invalid_fe_index) const
 

Protected Attributes

DoFHandler< 1, spacedim > * dof_handler
 
const Triangulation< 1, spacedim > * tria
 
VertexKind vertex_kind
 
unsigned int global_vertex_index
 

Friends

template<typename >
class TriaRawIterator
 
template<int , int >
class DoFHandler
 
struct ::internal::DoFHandlerImplementation::Policy::Implementation
 
struct ::internal::DoFHandlerImplementation::Implementation
 
struct ::internal::hp::DoFHandlerImplementation::Implementation
 
struct ::internal::DoFCellAccessorImplementation::Implementation
 

Accessing sub-objects

unsigned int vertex_index (const unsigned int i=0) const
 
Point< spacedim > & vertex (const unsigned int i=0) const
 
Point< spacedim > center () const
 
static typename::internal::TriangulationImplementation::Iterators< 1, spacedim >::line_iterator line (const unsigned int)
 
static unsigned int line_index (const unsigned int i)
 
static typename::internal::TriangulationImplementation::Iterators< 1, spacedim >::quad_iterator quad (const unsigned int i)
 
static unsigned int quad_index (const unsigned int i)
 

Detailed Description

template<int spacedim, bool level_dof_access>
class DoFAccessor< 0, 1, spacedim, level_dof_access >

Specialization of the general DoFAccessor class template for the case of zero-dimensional objects (a vertex) that are the face of a one-dimensional cell in spacedim space dimensions. Since vertices function differently than general faces, this class does a few things differently than the general template, but the interface should look the same.

Definition at line 766 of file dof_accessor.h.

Member Typedef Documentation

◆ BaseClass

template<int spacedim, bool level_dof_access>
using DoFAccessor< 0, 1, spacedim, level_dof_access >::BaseClass = TriaAccessor<0, 1, spacedim>

Declare an alias to the base class to make accessing some of the exception classes simpler.

Definition at line 786 of file dof_accessor.h.

◆ AccessorData

template<int spacedim, bool level_dof_access>
using DoFAccessor< 0, 1, spacedim, level_dof_access >::AccessorData = DoFHandler<1, spacedim>

Data type passed by the iterator class.

Definition at line 791 of file dof_accessor.h.

Member Enumeration Documentation

◆ VertexKind

template<int spacedim>
enum TriaAccessor< 0, 1, spacedim >::VertexKind
inherited

Whether the vertex represented here is at the left end of the domain, the right end, or in the interior.

Enumerator
left_vertex 

Left vertex.

interior_vertex 

Interior vertex.

right_vertex 

Right vertex.

Definition at line 2327 of file tria_accessor.h.

Constructor & Destructor Documentation

◆ DoFAccessor() [1/7]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( )

Default constructor. Provides an accessor that can't be used.

◆ DoFAccessor() [2/7]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( const Triangulation< 1, spacedim > *  tria,
const typename TriaAccessor< 0, 1, spacedim >::VertexKind  vertex_kind,
const unsigned int  vertex_index,
const DoFHandler< 1, spacedim > *  dof_handler 
)

Constructor to be used if the object here refers to a vertex of a one- dimensional triangulation, i.e. a face of the triangulation.

Since there is no mapping from vertices to cells, an accessor object for a point has no way to figure out whether it is at the boundary of the domain or not. Consequently, the second argument must be passed by the object that generates this accessor – e.g. a 1d cell that can figure out whether its left or right vertex are at the boundary.

The third argument is the global index of the vertex we point to.

The fourth argument is a pointer to the DoFHandler object.

This iterator can only be called for one-dimensional triangulations.

◆ DoFAccessor() [3/7]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( const Triangulation< 1, spacedim > *  ,
const int  = 0,
const int  = 0,
const DoFHandler< 1, spacedim > *  dof_handler = 0 
)

Constructor. This constructor exists in order to maintain interface compatibility with the other accessor classes. However, it doesn't do anything useful here and so may not actually be called except to default-construct iterator objects.

◆ DoFAccessor() [4/7]

template<int spacedim, bool level_dof_access>
template<int structdim2, int dim2, int spacedim2>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( const InvalidAccessor< structdim2, dim2, spacedim2 > &  )

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

◆ DoFAccessor() [5/7]

template<int spacedim, bool level_dof_access>
template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &  )

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

◆ DoFAccessor() [6/7]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( const DoFAccessor< 0, 1, spacedim, level_dof_access > &  )
default

Copy constructor.

◆ DoFAccessor() [7/7]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::DoFAccessor ( DoFAccessor< 0, 1, spacedim, level_dof_access > &&  )
default

Move constructor.

◆ ~DoFAccessor()

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access >::~DoFAccessor ( )
default

Destructor.

Member Function Documentation

◆ operator=() [1/2]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access > & DoFAccessor< 0, 1, spacedim, level_dof_access >::operator= ( const DoFAccessor< 0, 1, spacedim, level_dof_access > &  da)
delete

Copy operator. These operators are usually 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 DoF handler objects. Consequently, this operator is declared as deleted and can not be used.

◆ operator=() [2/2]

template<int spacedim, bool level_dof_access>
DoFAccessor< 0, 1, spacedim, level_dof_access > & DoFAccessor< 0, 1, spacedim, level_dof_access >::operator= ( DoFAccessor< 0, 1, spacedim, level_dof_access > &&  )
defaultnoexcept

Move assignment operator.

◆ get_dof_handler()

template<int spacedim, bool level_dof_access>
const DoFHandler< 1, spacedim > & DoFAccessor< 0, 1, spacedim, level_dof_access >::get_dof_handler ( ) const

Return a handle on the DoFHandler object which we are using.

◆ copy_from() [1/3]

template<int spacedim, bool level_dof_access>
template<bool level_dof_access2>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::copy_from ( const DoFAccessor< 0, 1, spacedim, level_dof_access2 > &  a)

Implement the copy operator needed for the iterator classes.

◆ copy_from() [2/3]

template<int spacedim, bool level_dof_access>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::copy_from ( const TriaAccessorBase< 0, 1, spacedim > &  da)

Copy operator used by the iterator class. Keeps the previously set dof handler, but sets the object coordinates of the TriaAccessor.

◆ child() [1/2]

template<int spacedim, bool level_dof_access>
TriaIterator< DoFAccessor< 0, 1, spacedim, level_dof_access > > DoFAccessor< 0, 1, spacedim, level_dof_access >::child ( const unsigned int  c) const

Return an invalid iterator of a type that represents pointing to a child of the current object. The object is invalid because points (as represented by the current class) do not have children.

◆ line() [1/2]

template<int spacedim, bool level_dof_access>
typename::internal::DoFHandlerImplementation::Iterators< 1, spacedim, level_dof_access >::line_iterator DoFAccessor< 0, 1, spacedim, level_dof_access >::line ( const unsigned int  i) const

Pointer to the ith line bounding this object.

Since meshes with dimension 1 do not have quads this method just throws an exception.

◆ quad() [1/2]

template<int spacedim, bool level_dof_access>
typename::internal::DoFHandlerImplementation::Iterators< 1, spacedim, level_dof_access >::quad_iterator DoFAccessor< 0, 1, spacedim, level_dof_access >::quad ( const unsigned int  i) const

Pointer to the ith quad bounding this object.

Since meshes with dimension 1 do not have quads this method just throws an exception.

◆ get_dof_indices()

template<int spacedim, bool level_dof_access>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::get_dof_indices ( std::vector< types::global_dof_index > &  dof_indices,
const unsigned int  fe_index = AccessorData::invalid_fe_index 
) const

Return the global indices of the degrees of freedom located on this object in the standard ordering defined by the finite element. This function is only available on active objects (see this glossary entry).

The present vertex must belong to an active cell (and not artificial in a parallel distributed computation).

The vector has to have the right size before being passed to this function.

The last argument denotes the finite element index. For the standard DoFHandler class, this value must be equal to its default value since that class only supports the same finite element on all cells anyway.

However, when the relevant DoFHandler has hp-capabilities, different finite element objects may be used on different cells. On faces between two cells, as well as vertices, there may therefore be two sets of degrees of freedom, one for each of the finite elements used on the adjacent cells. In order to specify which set of degrees of freedom to work on, the last argument is used to disambiguate. Finally, if this function is called for a cell object, there can only be a single set of degrees of freedom, and fe_index has to match the result of active_fe_index().

For cells, there is only a single possible finite element index (namely the one for that cell, returned by cell->active_fe_index. Consequently, the derived DoFCellAccessor class has an overloaded version of this function that calls the present function with cell->active_fe_index as last argument.

◆ get_mg_dof_indices()

template<int spacedim, bool level_dof_access>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::get_mg_dof_indices ( const int  level,
std::vector< types::global_dof_index > &  dof_indices,
const unsigned int  fe_index = AccessorData::invalid_fe_index 
) const

Return the global multilevel indices of the degrees of freedom that live on the current object with respect to the given level within the multigrid hierarchy. The indices refer to the local numbering for the level this line lives on.

◆ vertex_dof_index()

template<int spacedim, bool level_dof_access>
types::global_dof_index DoFAccessor< 0, 1, spacedim, level_dof_access >::vertex_dof_index ( const unsigned int  vertex,
const unsigned int  i,
const unsigned int  fe_index = AccessorData::invalid_fe_index 
) const

Global DoF index of the i degree associated with the vertexth vertex of the present cell.

The last argument denotes the finite element index. For the standard DoFHandler class, this value must be equal to its default value since that class only supports the same finite element on all cells anyway.

However, when the relevant DoFHandler has hp-capabilities, different finite element objects may be used on different cells. On faces between two cells, as well as vertices, there may therefore be two sets of degrees of freedom, one for each of the finite elements used on the adjacent cells. In order to specify which set of degrees of freedom to work on, the last argument is used to disambiguate. Finally, if this function is called for a cell object, there can only be a single set of degrees of freedom, and fe_index has to match the result of active_fe_index().

◆ dof_index()

template<int spacedim, bool level_dof_access>
types::global_dof_index DoFAccessor< 0, 1, spacedim, level_dof_access >::dof_index ( const unsigned int  i,
const unsigned int  fe_index = AccessorData::invalid_fe_index 
) const

Index of the ith degree of freedom of this object.

The last argument denotes the finite element index. For the standard DoFHandler class, this value must be equal to its default value since that class only supports the same finite element on all cells anyway.

However, when the relevant DoFHandler has hp-capabilities, different finite element objects may be used on different cells. On faces between two cells, as well as vertices, there may therefore be two sets of degrees of freedom, one for each of the finite elements used on the adjacent cells. In order to specify which set of degrees of freedom to work on, the last argument is used to disambiguate. Finally, if this function is called for a cell object, there can only be a single set of degrees of freedom, and fe_index has to match the result of active_fe_index().

◆ n_active_fe_indices()

template<int spacedim, bool level_dof_access>
unsigned int DoFAccessor< 0, 1, spacedim, level_dof_access >::n_active_fe_indices ( ) const

Return the number of finite elements that are active on a given object.

Since vertices do not store the information necessary for this to be calculated, this method just raises an exception and only exists to enable dimension-independent programming.

◆ nth_active_fe_index()

template<int spacedim, bool level_dof_access>
unsigned int DoFAccessor< 0, 1, spacedim, level_dof_access >::nth_active_fe_index ( const unsigned int  n) const

Return the n-th active FE index on this object.

Since vertices do not store the information necessary for this to be calculated, this method just raises an exception and only exists to enable dimension-independent programming.

◆ fe_index_is_active()

template<int spacedim, bool level_dof_access>
bool DoFAccessor< 0, 1, spacedim, level_dof_access >::fe_index_is_active ( const unsigned int  fe_index) const

Return true if the finite element with given index is active on the present object.

Since vertices do not store the information necessary for this to be calculated, this method just raises an exception and only exists to enable dimension-independent programming.

◆ get_fe()

template<int spacedim, bool level_dof_access>
const FiniteElement< 1, spacedim > & DoFAccessor< 0, 1, spacedim, level_dof_access >::get_fe ( const unsigned int  fe_index) const

Return a reference to the finite element used on this object with the given fe_index. fe_index must be used on this object, i.e. fe_index_is_active(fe_index) must return true.

◆ operator==() [1/2]

template<int spacedim, bool level_dof_access>
template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
bool DoFAccessor< 0, 1, spacedim, level_dof_access >::operator== ( const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &  ) const
protected

Compare for equality.

◆ operator!=() [1/2]

template<int spacedim, bool level_dof_access>
template<int structdim2, int dim2, int spacedim2, bool level_dof_access2>
bool DoFAccessor< 0, 1, spacedim, level_dof_access >::operator!= ( const DoFAccessor< structdim2, dim2, spacedim2, level_dof_access2 > &  ) const
protected

Compare for inequality.

◆ set_dof_handler()

template<int spacedim, bool level_dof_access>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::set_dof_handler ( DoFHandler< 1, spacedim > *  dh)
protected

Reset the DoF handler pointer.

◆ set_dof_index()

template<int spacedim, bool level_dof_access>
void DoFAccessor< 0, 1, spacedim, level_dof_access >::set_dof_index ( const unsigned int  i,
const types::global_dof_index  index,
const unsigned int  fe_index = AccessorData::invalid_fe_index 
) const
protected

Set the index of the ith degree of freedom of this object to index.

The last argument denotes the finite element index. For the standard DoFHandler class, this value must be equal to its default value since that class only supports the same finite element on all cells anyway.

However, when the relevant DoFHandler has hp-capabilities, different finite element objects may be used on different cells. On faces between two cells, as well as vertices, there may therefore be two sets of degrees of freedom, one for each of the finite elements used on the adjacent cells. In order to specify which set of degrees of freedom to work on, the last argument is used to disambiguate. Finally, if this function is called for a cell object, there can only be a single set of degrees of freedom, and fe_index has to match the result of active_fe_index().

◆ copy_from() [3/3]

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::copy_from ( const TriaAccessor< 0, 1, spacedim > &  )
inherited

Copy operator. Since this is only called from iterators, do not return anything, since the iterator will return itself.

◆ state()

template<int spacedim>
static IteratorState::IteratorStates TriaAccessor< 0, 1, spacedim >::state ( )
staticinherited

Return the state of the iterator. Since an iterator to points can not be incremented or decremented, its state remains constant, and in particular equal to IteratorState::valid.

◆ level()

template<int spacedim>
static int TriaAccessor< 0, 1, spacedim >::level ( )
staticinherited

Level of this object. Vertices have no level, so this function always returns zero.

◆ index()

template<int spacedim>
int TriaAccessor< 0, 1, spacedim >::index ( ) const
inherited

Index of this object. Returns the global index of the vertex this object points to.

◆ get_triangulation()

template<int spacedim>
const Triangulation< 1, spacedim > & TriaAccessor< 0, 1, spacedim >::get_triangulation ( ) const
inherited

Return a reference to the triangulation which the object pointed to by this class belongs to.

◆ operator++()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::operator++ ( ) const
inherited

This operator advances the iterator to the next element. For points, this operation is not defined, so you can't iterate over point iterators.

◆ operator--()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::operator-- ( ) const
inherited

This operator moves the iterator to the previous element. For points, this operation is not defined, so you can't iterate over point iterators.

◆ operator==() [2/2]

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::operator== ( const TriaAccessor< 0, 1, spacedim > &  ) const
inherited

Compare for equality.

◆ operator!=() [2/2]

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::operator!= ( const TriaAccessor< 0, 1, spacedim > &  ) const
inherited

Compare for inequality.

◆ operator<()

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::operator< ( const TriaAccessor< 0, 1, spacedim > &  other) const
inherited

Comparison operator for accessors. This operator is used when comparing iterators into objects of a triangulation, for example when putting them into a std::map.

This operator simply compares the global index of the vertex the current object points to.

◆ vertex_index()

template<int spacedim>
unsigned int TriaAccessor< 0, 1, spacedim >::vertex_index ( const unsigned int  i = 0) const
inherited

Return the global index of i-th vertex of the current object. If i is zero, this returns the index of the current point to which this object refers. Otherwise, it throws an exception.

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.

Note
Despite the name, the index returned here is only global in the sense that it is specific to a particular Triangulation object or, in the case the triangulation is actually of type parallel::distributed::Triangulation, specific to that part of the distributed triangulation stored on the current processor.

◆ vertex()

template<int spacedim>
Point< spacedim > & TriaAccessor< 0, 1, spacedim >::vertex ( const unsigned int  i = 0) const
inherited

Return a reference to the ith vertex. If i is zero, this returns a reference to the current point to which this object refers. Otherwise, it throws an exception.

◆ center()

template<int spacedim>
Point< spacedim > TriaAccessor< 0, 1, spacedim >::center ( ) const
inherited

Return the center of this object, which of course coincides with the location of the vertex this object refers to.

◆ line() [2/2]

template<int spacedim>
static typename::internal::TriangulationImplementation::Iterators< 1, spacedim >::line_iterator TriaAccessor< 0, 1, spacedim >::line ( const unsigned int  )
staticinherited

Pointer to the ith line bounding this object. Will point to an invalid object.

◆ line_index()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::line_index ( const unsigned int  i)
staticinherited

Line index of the ith line bounding this object.

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

◆ quad() [2/2]

template<int spacedim>
static typename::internal::TriangulationImplementation::Iterators< 1, spacedim >::quad_iterator TriaAccessor< 0, 1, spacedim >::quad ( const unsigned int  i)
staticinherited

Pointer to the ith quad bounding this object.

◆ quad_index()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::quad_index ( const unsigned int  i)
staticinherited

Quad index of the ith quad bounding this object.

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

◆ at_boundary()

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::at_boundary ( ) const
inherited

Return whether this point is at the boundary of the one-dimensional triangulation we deal with here.

◆ boundary_id()

template<int spacedim>
types::boundary_id TriaAccessor< 0, 1, spacedim >::boundary_id ( ) const
inherited

Return the boundary indicator of this object. The convention for one dimensional triangulations is that left end vertices (of each line segment from which the triangulation may be constructed) have boundary indicator zero, and right end vertices have boundary indicator one, unless explicitly set differently.

If the return value is the special value numbers::internal_face_boundary_id, then this object is in the interior of the domain.

See also
Glossary entry on boundary indicators

◆ get_manifold()

template<int spacedim>
const Manifold< 1, spacedim > & TriaAccessor< 0, 1, spacedim >::get_manifold ( ) const
inherited

Return a constant reference to the manifold object used for this object.

◆ manifold_id()

template<int spacedim>
types::manifold_id TriaAccessor< 0, 1, spacedim >::manifold_id ( ) const
inherited

Return the manifold indicator of this object.

See also
Glossary entry on manifold indicators.

◆ user_flag_set()

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::user_flag_set
inherited

Read the user flag. See GlossUserFlags for more information.

Definition at line 1806 of file tria_accessor.cc.

◆ set_user_flag()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_user_flag
inherited

Set the user flag. See GlossUserFlags for more information.

Definition at line 1817 of file tria_accessor.cc.

◆ clear_user_flag()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::clear_user_flag
inherited

Clear the user flag. See GlossUserFlags for more information.

Definition at line 1827 of file tria_accessor.cc.

◆ recursively_set_user_flag()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_set_user_flag
inherited

Set the user flag for this and all descendants. See GlossUserFlags for more information.

Definition at line 1837 of file tria_accessor.cc.

◆ recursively_clear_user_flag()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_clear_user_flag
inherited

Clear the user flag for this and all descendants. See GlossUserFlags for more information.

Definition at line 1850 of file tria_accessor.cc.

◆ clear_user_data()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::clear_user_data
inherited

Reset the user data to zero, independent if pointer or index. See GlossUserData for more information.

Definition at line 1863 of file tria_accessor.cc.

◆ set_user_pointer()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_user_pointer ( void *  p) const
inherited

Set the user pointer to p.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between.

See GlossUserData for more information.

Definition at line 1873 of file tria_accessor.cc.

◆ clear_user_pointer()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::clear_user_pointer
inherited

Reset the user pointer to a nullptr pointer. See GlossUserData for more information.

Definition at line 1883 of file tria_accessor.cc.

◆ user_pointer()

template<int spacedim>
void * TriaAccessor< 0, 1, spacedim >::user_pointer
inherited

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 type safety, e.g.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between. A a=static_cast<A>(cell->user_pointer());.

See GlossUserData for more information.

Definition at line 1893 of file tria_accessor.cc.

◆ recursively_set_user_pointer()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_set_user_pointer ( void *  p) const
inherited

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.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between.

See GlossUserData for more information.

Definition at line 1904 of file tria_accessor.cc.

◆ recursively_clear_user_pointer()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_clear_user_pointer
inherited

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

Definition at line 1917 of file tria_accessor.cc.

◆ set_user_index()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_user_index ( const unsigned int  p) const
inherited

Set the user index to p.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between. See GlossUserData for more information.

Definition at line 1930 of file tria_accessor.cc.

◆ clear_user_index()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::clear_user_index
inherited

Reset the user index to 0. See GlossUserData for more information.

Definition at line 1940 of file tria_accessor.cc.

◆ user_index()

template<int spacedim>
unsigned int TriaAccessor< 0, 1, spacedim >::user_index
inherited

Access the value of the user index.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between.

See GlossUserData for more information.

Definition at line 1950 of file tria_accessor.cc.

◆ recursively_set_user_index()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_set_user_index ( const unsigned int  p) const
inherited

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.

Note
User pointers and user indices are mutually exclusive. Therefore, you can only use one of them, unless you call Triangulation::clear_user_data() in between.

See GlossUserData for more information.

Definition at line 1961 of file tria_accessor.cc.

◆ recursively_clear_user_index()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::recursively_clear_user_index
inherited

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

See GlossUserData for more information.

Definition at line 1974 of file tria_accessor.cc.

◆ combined_face_orientation()

template<int spacedim>
static unsigned char TriaAccessor< 0, 1, spacedim >::combined_face_orientation ( const unsigned int  face)
staticinherited

Always return 0.

◆ face_orientation()

template<int spacedim>
static bool TriaAccessor< 0, 1, spacedim >::face_orientation ( const unsigned int  face)
staticinherited

Always return false.

◆ face_flip()

template<int spacedim>
static bool TriaAccessor< 0, 1, spacedim >::face_flip ( const unsigned int  face)
staticinherited

Always return false.

◆ face_rotation()

template<int spacedim>
static bool TriaAccessor< 0, 1, spacedim >::face_rotation ( const unsigned int  face)
staticinherited

Always return false.

◆ line_orientation()

template<int spacedim>
static bool TriaAccessor< 0, 1, spacedim >::line_orientation ( const unsigned int  line)
staticinherited

Always return false.

◆ has_children()

template<int spacedim>
static bool TriaAccessor< 0, 1, spacedim >::has_children ( )
staticinherited

Test whether the object has children. Always false.

◆ n_children()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::n_children ( )
staticinherited

Return the number of immediate children of this object.This is always zero in dimension 0.

◆ n_active_descendants()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::n_active_descendants ( )
staticinherited

Compute and return the number of active descendants of this objects. Always zero.

◆ number_of_children()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::number_of_children ( )
staticinherited

◆ max_refinement_depth()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::max_refinement_depth ( )
staticinherited

Return the number of times that this object is refined. Always 0.

◆ child_iterator_to_index()

template<int spacedim>
static unsigned int TriaAccessor< 0, 1, spacedim >::child_iterator_to_index ( const TriaIterator< TriaAccessor< 0, 1, spacedim > > &  )
staticinherited

Return an invalid unsigned integer.

◆ child() [2/2]

template<int spacedim>
static TriaIterator< TriaAccessor< 0, 1, spacedim > > TriaAccessor< 0, 1, spacedim >::child ( const unsigned int  )
staticinherited

Return an invalid object.

◆ isotropic_child()

template<int spacedim>
static TriaIterator< TriaAccessor< 0, 1, spacedim > > TriaAccessor< 0, 1, spacedim >::isotropic_child ( const unsigned int  )
staticinherited

Return an invalid object.

◆ refinement_case()

template<int spacedim>
static RefinementCase< 0 > TriaAccessor< 0, 1, spacedim >::refinement_case ( )
staticinherited

Always return no refinement.

◆ child_index()

template<int spacedim>
static int TriaAccessor< 0, 1, spacedim >::child_index ( const unsigned int  i)
staticinherited

Returns -1.

◆ isotropic_child_index()

template<int spacedim>
static int TriaAccessor< 0, 1, spacedim >::isotropic_child_index ( const unsigned int  i)
staticinherited

Returns -1.

◆ set_boundary_id()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_boundary_id ( const types::boundary_id  ) const
inherited

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

Warning
You should never set the boundary indicator of an interior face (a face not at the boundary of the domain), or set the boundary indicator of an exterior face to numbers::internal_face_boundary_id (this value is reserved for another purpose). Algorithms may not work or produce very confusing results if boundary cells have a boundary indicator of numbers::internal_face_boundary_id or if interior cells have boundary indicators other than numbers::internal_face_boundary_id. 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.
See also
Glossary entry on boundary indicators

◆ set_manifold_id()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_manifold_id ( const types::manifold_id  )
inherited

Set the manifold indicator of this vertex. This does nothing so far since manifolds are only used to refine and map objects, but vertices are not refined and the mapping is trivial. This function is here only to allow dimension independent programming.

◆ set_all_boundary_ids()

template<int spacedim>
void TriaAccessor< 0, 1, spacedim >::set_all_boundary_ids ( const types::boundary_id  ) const
inherited

Set the boundary indicator of this object and all of its lower- dimensional sub-objects. Since this object only represents a single vertex, there are no lower-dimensional object and this function is equivalent to calling set_boundary_id() with the same argument.

See also
Glossary entry on boundary indicators

◆ used()

template<int spacedim>
bool TriaAccessor< 0, 1, spacedim >::used ( ) const
inherited

Return whether the vertex pointed to here is used.

◆ reference_cell()

template<int spacedim>
ReferenceCell TriaAccessor< 0, 1, spacedim >::reference_cell ( ) const
inherited

Reference cell type of the current object.

◆ n_vertices()

template<int spacedim>
unsigned int TriaAccessor< 0, 1, spacedim >::n_vertices ( ) const
inherited

Number of vertices.

◆ n_lines()

template<int spacedim>
unsigned int TriaAccessor< 0, 1, spacedim >::n_lines ( ) const
inherited

Number of lines.

◆ vertex_indices()

template<int spacedim>
std_cxx20::ranges::iota_view< unsigned int, unsigned int > TriaAccessor< 0, 1, spacedim >::vertex_indices ( ) const
inherited

Return an object that can be thought of as an array containing all indices from zero to n_vertices().

◆ line_indices()

template<int spacedim>
std_cxx20::ranges::iota_view< unsigned int, unsigned int > TriaAccessor< 0, 1, spacedim >::line_indices ( ) const
inherited

Return an object that can be thought of as an array containing all indices from zero to n_lines().

Friends And Related Function Documentation

◆ TriaRawIterator

template<int spacedim, bool level_dof_access>
template<typename >
friend class TriaRawIterator
friend

Definition at line 1210 of file dof_accessor.h.

◆ DoFHandler

template<int spacedim, bool level_dof_access>
template<int , int >
friend class DoFHandler
friend

Manage the distribution and numbering of the degrees of freedom for hp- FEM algorithms. This class satisfies the MeshType concept requirements.

The purpose of this class is to allow for an enumeration of degrees of freedom in the same way as the DoFHandler class, but it allows to use a different finite element on every cell. To this end, one assigns an active_fe_index to every cell that indicates which element within a collection of finite elements (represented by an object of type hp::FECollection) is the one that lives on this cell. The class then enumerates the degree of freedom associated with these finite elements on each cell of a triangulation and, if possible, identifies degrees of freedom at the interfaces of cells if they match. If neighboring cells have degrees of freedom along the common interface that do not immediate match (for example, if you have \(Q_2\) and \(Q_3\) elements meeting at a common face), then one needs to compute constraints to ensure that the resulting finite element space on the mesh remains conforming.

The whole process of working with objects of this type is explained in step-27. Many of the algorithms this class implements are described in the hp-paper.

Active FE indices and their behavior under mesh refinement

The typical workflow for using this class is to create a mesh, assign an active FE index to every active cell, calls hp::DoFHandler::distribute_dofs(), and then assemble a linear system and solve a problem on this finite element space. However, one can skip assigning active FE indices upon mesh refinement in certain circumstances. In particular, the following rules apply:

  • Upon mesh refinement, child cells inherit the active FE index of the parent.
  • When coarsening cells, the (now active) parent cell will be assigned an active FE index that is determined from its (no longer active) children, following the FiniteElementDomination logic: Out of the set of elements previously assigned to the former children, we choose the one dominated by all children for the parent cell. If none was found, we pick the most dominant element in the whole collection that is dominated by all former children. See hp::FECollection::find_dominated_fe_extended() for further information on this topic.
Note
Finite elements need to be assigned to each cell by either calling set_fe() or distribute_dofs() first to make this functionality available.

Active FE indices and parallel meshes

When this class is used with either a parallel::shared::Triangulation or a parallel::distributed::Triangulation, you can only set active FE indices on cells that are locally owned, using a call such as cell->set_active_fe_index(...). On the other hand, setting the active FE index on ghost or artificial cells is not allowed.

Ghost cells do acquire the information what element is active on them, however: whenever you call hp::DoFHandler::distribute_dofs(), all processors that participate in the parallel mesh exchange information in such a way that the active FE index on ghost cells equals the active FE index that was set on that processor that owned that particular ghost cell. Consequently, one can query the active_fe_index on ghost cells, just not set it by hand.

On artificial cells, no information is available about the active_fe_index used there. That's because we don't even know whether these cells exist at all, and even if they did, the current processor does not know anything specific about them. See the glossary entry on artificial cells for more information.

During refinement and coarsening, information about the active_fe_index of each cell will be automatically transferred.

However, using a parallel::distributed::Triangulation with an hp::DoFHandler requires additional attention during serialization, since no information on active FE indices will be automatically transferred. This has to be done manually using the prepare_for_serialization_of_active_fe_indices() and deserialize_active_fe_indices() functions. The former has to be called before parallel::distributed::Triangulation::save() is invoked, and the latter needs to be run after parallel::distributed::Triangulation::load(). If further data will be attached to the triangulation via the parallel::distributed::CellDataTransfer, parallel::distributed::SolutionTransfer, or Particles::ParticleHandler classes, all corresponding preparation and deserialization function calls need to happen in the same order. Consult the documentation of parallel::distributed::SolutionTransfer for more information.

Deprecated:
The basic DoFHandler is capable of hp-adaptation now.

Definition at line 1216 of file dof_accessor.h.

◆ ::internal::DoFHandlerImplementation::Policy::Implementation

template<int spacedim, bool level_dof_access>
friend struct ::internal::DoFHandlerImplementation::Policy::Implementation
friend

Definition at line 1218 of file dof_accessor.h.

◆ ::internal::DoFHandlerImplementation::Implementation

template<int spacedim, bool level_dof_access>
friend struct ::internal::DoFHandlerImplementation::Implementation
friend

Definition at line 1220 of file dof_accessor.h.

◆ ::internal::hp::DoFHandlerImplementation::Implementation

template<int spacedim, bool level_dof_access>
friend struct ::internal::hp::DoFHandlerImplementation::Implementation
friend

Definition at line 1221 of file dof_accessor.h.

◆ ::internal::DoFCellAccessorImplementation::Implementation

template<int spacedim, bool level_dof_access>
friend struct ::internal::DoFCellAccessorImplementation::Implementation
friend

Definition at line 1222 of file dof_accessor.h.

Member Data Documentation

◆ dimension

template<int spacedim, bool level_dof_access>
constexpr unsigned int DoFAccessor< 0, 1, spacedim, level_dof_access >::dimension = 1
staticconstexpr

A static variable that allows users of this class to discover the value of the second template argument.

Definition at line 774 of file dof_accessor.h.

◆ space_dimension

template<int spacedim, bool level_dof_access>
constexpr unsigned int DoFAccessor< 0, 1, spacedim, level_dof_access >::space_dimension = spacedim
staticconstexpr

A static variable that allows users of this class to discover the value of the third template argument.

Definition at line 780 of file dof_accessor.h.

◆ dof_handler

template<int spacedim, bool level_dof_access>
DoFHandler<1, spacedim>* DoFAccessor< 0, 1, spacedim, level_dof_access >::dof_handler
protected

Store the address of the DoFHandler object to be accessed.

Definition at line 1159 of file dof_accessor.h.

◆ structure_dimension

template<int spacedim>
const unsigned int TriaAccessor< 0, 1, spacedim >::structure_dimension = 0
staticinherited

Dimensionality of the current object represented by this accessor. For example, if it is line (irrespective of whether it is part of a quad or hex, and what dimension we are in), then this value equals 1.

Definition at line 2316 of file tria_accessor.h.

◆ tria

template<int spacedim>
const Triangulation<1, spacedim>* TriaAccessor< 0, 1, spacedim >::tria
protectedinherited

Pointer to the triangulation we operate on.

Definition at line 3016 of file tria_accessor.h.

◆ vertex_kind

template<int spacedim>
VertexKind TriaAccessor< 0, 1, spacedim >::vertex_kind
protectedinherited

Whether this is a left end, right end, or interior vertex. This information is provided by the cell at the time of creation.

Definition at line 3022 of file tria_accessor.h.

◆ global_vertex_index

template<int spacedim>
unsigned int TriaAccessor< 0, 1, spacedim >::global_vertex_index
protectedinherited

The global vertex index of the vertex this object corresponds to.

Definition at line 3027 of file tria_accessor.h.


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