Reference documentation for deal.II version 9.6.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
GeometryInfo< 0 > Struct Reference

#include <deal.II/base/geometry_info.h>

Inheritance diagram for GeometryInfo< 0 >:

Static Public Member Functions

static std::array< unsigned int, 0 > face_indices ()
 
static unsigned int n_children (const RefinementCase< 0 > &refinement_case)
 
static std::array< unsigned int, vertices_per_cellvertex_indices ()
 
static unsigned int face_to_cell_vertices (const unsigned int face, const unsigned int vertex, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int face_to_cell_lines (const unsigned int face, const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static std_cxx20::ranges::iota_view< unsigned int, unsigned intface_indices ()
 
static std_cxx20::ranges::iota_view< unsigned int, unsigned intvertex_indices ()
 
static unsigned int n_children (const RefinementCase< dim > &refinement_case)
 
static unsigned int n_subfaces (const internal::SubfaceCase< dim > &subface_case)
 
static double subface_ratio (const internal::SubfaceCase< dim > &subface_case, const unsigned int subface_no)
 
static RefinementCase< dim - 1 > face_refinement_case (const RefinementCase< dim > &cell_refinement_case, const unsigned int face_no, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static RefinementCase< dim > min_cell_refinement_case_for_face_refinement (const RefinementCase< dim - 1 > &face_refinement_case, const unsigned int face_no, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static RefinementCase< 1 > line_refinement_case (const RefinementCase< dim > &cell_refinement_case, const unsigned int line_no)
 
static RefinementCase< dim > min_cell_refinement_case_for_line_refinement (const unsigned int line_no)
 
static unsigned int child_cell_on_face (const RefinementCase< dim > &ref_case, const unsigned int face, const unsigned int subface, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false, const RefinementCase< dim - 1 > &face_refinement_case=RefinementCase< dim - 1 >::isotropic_refinement)
 
static unsigned int line_to_cell_vertices (const unsigned int line, const unsigned int vertex)
 
static unsigned int face_to_cell_vertices (const unsigned int face, const unsigned int vertex, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int face_to_cell_lines (const unsigned int face, const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int standard_to_real_face_vertex (const unsigned int vertex, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int real_to_standard_face_vertex (const unsigned int vertex, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int standard_to_real_face_line (const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static unsigned int standard_to_real_line_vertex (const unsigned int vertex, const bool line_orientation=true)
 
static std::array< unsigned int, 2 > standard_quad_vertex_to_line_vertex_index (const unsigned int vertex)
 
static std::array< unsigned int, 2 > standard_hex_vertex_to_quad_vertex_index (const unsigned int vertex)
 
static std::array< unsigned int, 2 > standard_hex_line_to_quad_line_index (const unsigned int line)
 
static unsigned int real_to_standard_face_line (const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
 
static Point< dim > unit_cell_vertex (const unsigned int vertex)
 
static unsigned int child_cell_from_point (const Point< dim > &p)
 
static Point< dim > cell_to_child_coordinates (const Point< dim > &p, const unsigned int child_index, const RefinementCase< dim > refine_case=RefinementCase< dim >::isotropic_refinement)
 
static Point< dim > child_to_cell_coordinates (const Point< dim > &p, const unsigned int child_index, const RefinementCase< dim > refine_case=RefinementCase< dim >::isotropic_refinement)
 
static bool is_inside_unit_cell (const Point< dim > &p)
 
static bool is_inside_unit_cell (const Point< dim > &p, const double eps)
 
static Point< dim, Number > project_to_unit_cell (const Point< dim, Number > &p)
 
static double distance_to_unit_cell (const Point< dim > &p)
 
static double d_linear_shape_function (const Point< dim > &xi, const unsigned int i)
 
static Tensor< 1, dim > d_linear_shape_function_gradient (const Point< dim > &xi, const unsigned int i)
 
static void alternating_form_at_vertices (const Point< spacedim >(&vertices)[vertices_per_cell], Tensor< spacedim - dim, spacedim >(&forms)[vertices_per_cell])
 
static ::ExceptionBaseExcInvalidCoordinate (double arg1)
 
static ::ExceptionBaseExcInvalidSubface (int arg1, int arg2, int arg3)
 

Static Public Attributes

static constexpr unsigned int max_children_per_cell = 1
 
static constexpr unsigned int faces_per_cell = 0
 
static constexpr unsigned int max_children_per_face = 0
 
static constexpr unsigned int vertices_per_cell = 1
 
static constexpr unsigned int vertices_per_face = 0
 
static constexpr unsigned int lines_per_face = 0
 
static constexpr unsigned int quads_per_face = 0
 
static constexpr unsigned int lines_per_cell = 0
 
static constexpr unsigned int quads_per_cell = 0
 
static constexpr unsigned int hexes_per_cell = 0
 
static const std::array< unsigned int, vertices_per_cellucd_to_deal
 
static const std::array< unsigned int, vertices_per_celldx_to_deal
 
static constexpr unsigned int max_children_per_cell
 
static constexpr unsigned int faces_per_cell
 
static constexpr unsigned int max_children_per_face
 
static constexpr unsigned int vertices_per_cell
 
static constexpr unsigned int vertices_per_face
 
static constexpr unsigned int lines_per_face
 
static constexpr unsigned int quads_per_face
 
static constexpr unsigned int lines_per_cell
 
static constexpr unsigned int quads_per_cell
 
static constexpr unsigned int hexes_per_cell
 
static constexpr std::array< unsigned int, vertices_per_cellucd_to_deal
 
static constexpr std::array< unsigned int, vertices_per_celldx_to_deal
 
static constexpr ndarray< unsigned int, vertices_per_cell, dim > vertex_to_face
 
static constexpr std::array< unsigned int, faces_per_cellunit_normal_direction
 
static constexpr std::array< int, faces_per_cellunit_normal_orientation
 
static constexpr std::array< Tensor< 1, dim >, faces_per_cellunit_normal_vector
 
static constexpr ndarray< Tensor< 1, dim >, faces_per_cell, dim - 1 > unit_tangential_vectors
 
static constexpr std::array< unsigned int, faces_per_cellopposite_face
 

Detailed Description

This class provides a description of zero-dimensional cells. It has been superseded by the ReferenceCell class – see there for more information.

Topological description of zero dimensional cells, i.e. points. This class might not look too useful but often is if in a certain dimension we would like to enquire information about objects with dimension one lower than the present, e.g. about faces.

This class contains as static members information on vertices and faces of a dim-dimensional grid cell. The interface is the same for all dimensions. If a value is of no use in a low dimensional cell, it is (correctly) set to zero, e.g. max_children_per_face in 1d.

This information should always replace hard-coded numbers of vertices, neighbors and so on, since it can be used dimension independently.

Definition at line 1232 of file geometry_info.h.

Member Function Documentation

◆ face_indices() [1/2]

static std::array< unsigned int, 0 > GeometryInfo< 0 >::face_indices ( )
static

Return an object that can be thought of as an array containing all indices from zero to faces_per_cell. This allows to write code using range-based for loops of the following kind:

for (auto &cell : triangulation.active_cell_iterators())
for (auto face_index : GeometryInfo<dim>::face_indices())
if (cell->face(face_index)->at_boundary())
... do something ...
static std_cxx20::ranges::iota_view< unsigned int, unsigned int > face_indices()

Here, we are looping over all faces of all cells, with face_index taking on all valid indices.

Of course, since this class is for the case dim==0, the returned object is actually an empty array.

◆ n_children() [1/2]

static unsigned int GeometryInfo< 0 >::n_children ( const RefinementCase< 0 > & refinement_case)
static

Return the number of children of a cell (or face) refined with ref_case. Since we are concerned here with points, the number of children is equal to one.

◆ vertex_indices() [1/2]

static std::array< unsigned int, vertices_per_cell > GeometryInfo< 0 >::vertex_indices ( )
static

Return an object that can be thought of as an array containing all indices from zero to vertices_per_cell. This allows to write code using range-based for loops of the following kind:

for (auto &cell : triangulation.active_cell_iterators())
for (auto vertex_index : GeometryInfo<dim>::vertex_indices())
if (cell->vertex(vertex_index) satisfies some condition)
... do something ...
static std_cxx20::ranges::iota_view< unsigned int, unsigned int > vertex_indices()

Here, we are looping over all vertices of all cells, with vertex_index taking on all valid indices.

Of course, since this class is for the case dim==0, the returned object is a array with just one entry: zero. That's because an of dimension zero is really just a single point, corresponding to a vertex itself.

◆ face_to_cell_vertices() [1/2]

static unsigned int GeometryInfo< 0 >::face_to_cell_vertices ( const unsigned int face,
const unsigned int vertex,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map face vertex number to cell vertex number, i.e. give the cell vertex number of the vertexth vertex of face face, e.g. GeometryInfo<2>::face_to_cell_vertices(3,0)=2, see the image under point N4 in the 2d section of this class's documentation.

Through the face_orientation, face_flip and face_rotation arguments this function handles faces oriented in the standard and non-standard orientation. face_orientation defaults to true, face_flip and face_rotation default to false (standard orientation). In 2d only face_flip is considered. See this glossary article for more information.

As the children of a cell are ordered according to the vertices of the cell, this call is passed down to the child_cell_on_face() function. Hence this function is simply a wrapper of child_cell_on_face() giving it a suggestive name.

Of course, since this class is for the case dim==0, this function is not implemented.

◆ face_to_cell_lines() [1/2]

static unsigned int GeometryInfo< 0 >::face_to_cell_lines ( const unsigned int face,
const unsigned int line,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map face line number to cell line number, i.e. give the cell line number of the lineth line of face face, e.g. GeometryInfo<3>::face_to_cell_lines(5,0)=4.

Through the face_orientation, face_flip and face_rotation arguments this function handles faces oriented in the standard and non-standard orientation. face_orientation defaults to true, face_flip and face_rotation default to false (standard orientation) and has no effect in 2d.

Of course, since this class is for the case dim==0, this function is not implemented.

◆ face_indices() [2/2]

static std_cxx20::ranges::iota_view< unsigned int, unsigned int > GeometryInfo< dim >::face_indices ( )
static

Return an object that can be thought of as an array containing all indices from zero to faces_per_cell. This allows to write code using range-based for loops of the following kind:

for (auto &cell : triangulation.active_cell_iterators())
for (auto face_index : GeometryInfo<dim>::face_indices())
if (cell->face(face_index)->at_boundary())
... do something ...

Here, we are looping over all faces of all cells, with face_index taking on all valid indices for faces (zero and one in 1d, zero through three in 2d, and zero through 5 in 3d).

See also
deal.II and Modern C++ standards

◆ vertex_indices() [2/2]

static std_cxx20::ranges::iota_view< unsigned int, unsigned int > GeometryInfo< dim >::vertex_indices ( )
static

Return an object that can be thought of as an array containing all indices from zero to vertices_per_cell. This allows to write code using range-based for loops of the following kind:

for (auto &cell : triangulation.active_cell_iterators())
for (auto vertex_index : GeometryInfo<dim>::vertex_indices())
if (cell->vertex(vertex_index) satisfies some condition)
... do something ...

Here, we are looping over all vertices of all cells, with vertex_index taking on all valid indices.

See also
deal.II and Modern C++ standards

◆ n_children() [2/2]

static unsigned int GeometryInfo< dim >::n_children ( const RefinementCase< dim > & refinement_case)
static

Return the number of children of a cell (or face) refined with ref_case.

◆ n_subfaces()

static unsigned int GeometryInfo< dim >::n_subfaces ( const internal::SubfaceCase< dim > & subface_case)
static

Return the number of subfaces of a face refined according to internal::SubfaceCase face_ref_case.

◆ subface_ratio()

static double GeometryInfo< dim >::subface_ratio ( const internal::SubfaceCase< dim > & subface_case,
const unsigned int subface_no )
static

Given a face on the reference element with a internal::SubfaceCase<dim> face_refinement_case this function returns the ratio between the area of the subface_no th subface and the area(=1) of the face.

E.g. for internal::SubfaceCase::cut_xy the ratio is 1/4 for each of the subfaces.

◆ face_refinement_case()

static RefinementCase< dim - 1 > GeometryInfo< dim >::face_refinement_case ( const RefinementCase< dim > & cell_refinement_case,
const unsigned int face_no,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Given a cell refined with the RefinementCase cell_refinement_case return the SubfaceCase of the face_no th face.

◆ min_cell_refinement_case_for_face_refinement()

static RefinementCase< dim > GeometryInfo< dim >::min_cell_refinement_case_for_face_refinement ( const RefinementCase< dim - 1 > & face_refinement_case,
const unsigned int face_no,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Given the SubfaceCase face_refinement_case of the face_no th face, return the smallest RefinementCase of the cell, which corresponds to that refinement of the face.

◆ line_refinement_case()

static RefinementCase< 1 > GeometryInfo< dim >::line_refinement_case ( const RefinementCase< dim > & cell_refinement_case,
const unsigned int line_no )
static

Given a cell refined with the RefinementCase cell_refinement_case return the RefinementCase of the line_no th face.

◆ min_cell_refinement_case_for_line_refinement()

static RefinementCase< dim > GeometryInfo< dim >::min_cell_refinement_case_for_line_refinement ( const unsigned int line_no)
static

Return the minimal / smallest RefinementCase of the cell, which ensures refinement of line line_no.

◆ child_cell_on_face()

static unsigned int GeometryInfo< dim >::child_cell_on_face ( const RefinementCase< dim > & ref_case,
const unsigned int face,
const unsigned int subface,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false,
const RefinementCase< dim - 1 > & face_refinement_case = RefinementCase<dim - 1>::isotropic_refinement )
static

This field stores which child cells are adjacent to a certain face of the mother cell.

For example, in 2d the layout of a cell is as follows:

* .      3
* .   2-->--3
* .   |     |
* . 0 ^     ^ 1
* .   |     |
* .   0-->--1
* .      2
* 

Vertices and faces are indicated with their numbers, faces also with their directions.

Now, when refined, the layout is like this:

* *--*--*
* | 2|3 |
* *--*--*
* | 0|1 |
* *--*--*
* 

Thus, the child cells on face 0 are (ordered in the direction of the face) 0 and 2, on face 3 they are 2 and 3, etc.

For three spatial dimensions, the exact order of the children is laid down in the general documentation of this class.

Through the face_orientation, face_flip and face_rotation arguments this function handles faces oriented in the standard and non-standard orientation. face_orientation defaults to true, face_flip and face_rotation default to false (standard orientation) and has no effect in 2d. The concept of face orientations is explained in this glossary entry.

In the case of anisotropically refined cells and faces, the RefinementCase of the face, face_ref_case, might have an influence on which child is behind which given subface, thus this is an additional argument, defaulting to isotropic refinement of the face.

◆ line_to_cell_vertices()

static unsigned int GeometryInfo< dim >::line_to_cell_vertices ( const unsigned int line,
const unsigned int vertex )
static

Map line vertex number to cell vertex number, i.e. give the cell vertex number of the vertexth vertex of line line, e.g. GeometryInfo<2>::line_to_cell_vertices(3,0)=2.

The order of the lines, as well as their direction (which in turn determines which is the first and which the second vertex on a line) is the canonical one in deal.II, as described in the general documentation of this class.

For dim=2 this call is simply passed down to the face_to_cell_vertices() function.

◆ face_to_cell_vertices() [2/2]

static unsigned int GeometryInfo< dim >::face_to_cell_vertices ( const unsigned int face,
const unsigned int vertex,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map face vertex number to cell vertex number, i.e. give the cell vertex number of the vertexth vertex of face face, e.g. GeometryInfo<2>::face_to_cell_vertices(3,0)=2, see the image under point N4 in the 2d section of this class's documentation.

Through the face_orientation, face_flip and face_rotation arguments this function handles faces oriented in the standard and non-standard orientation. face_orientation defaults to true, face_flip and face_rotation default to false (standard orientation). In 2d only face_flip is considered. See this glossary article for more information.

As the children of a cell are ordered according to the vertices of the cell, this call is passed down to the child_cell_on_face() function. Hence this function is simply a wrapper of child_cell_on_face() giving it a suggestive name.

◆ face_to_cell_lines() [2/2]

static unsigned int GeometryInfo< dim >::face_to_cell_lines ( const unsigned int face,
const unsigned int line,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map face line number to cell line number, i.e. give the cell line number of the lineth line of face face, e.g. GeometryInfo<3>::face_to_cell_lines(5,0)=4.

Through the face_orientation, face_flip and face_rotation arguments this function handles faces oriented in the standard and non-standard orientation. face_orientation defaults to true, face_flip and face_rotation default to false (standard orientation) and has no effect in 2d.

◆ standard_to_real_face_vertex()

static unsigned int GeometryInfo< dim >::standard_to_real_face_vertex ( const unsigned int vertex,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map the vertex index vertex of a face in standard orientation to one of a face with arbitrary face_orientation, face_flip and face_rotation. The values of these three flags default to true, false and false, respectively. this combination describes a face in standard orientation.

This function is only implemented in 3d.

◆ real_to_standard_face_vertex()

static unsigned int GeometryInfo< dim >::real_to_standard_face_vertex ( const unsigned int vertex,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map the vertex index vertex of a face with arbitrary face_orientation, face_flip and face_rotation to a face in standard orientation. The values of these three flags default to true, false and false, respectively. this combination describes a face in standard orientation.

This function is only implemented in 3d.

◆ standard_to_real_face_line()

static unsigned int GeometryInfo< dim >::standard_to_real_face_line ( const unsigned int line,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map the line index line of a face in standard orientation to one of a face with arbitrary face_orientation, face_flip and face_rotation. The values of these three flags default to true, false and false, respectively. this combination describes a face in standard orientation.

This function is only implemented in 3d.

◆ standard_to_real_line_vertex()

static unsigned int GeometryInfo< dim >::standard_to_real_line_vertex ( const unsigned int vertex,
const bool line_orientation = true )
static

Map the vertex index vertex of a line in standard orientation to one of a face with arbitrary line_orientation. The value of this flag default to true.

◆ standard_quad_vertex_to_line_vertex_index()

static std::array< unsigned int, 2 > GeometryInfo< dim >::standard_quad_vertex_to_line_vertex_index ( const unsigned int vertex)
static

Decompose the vertex index in a quad into a pair of a line index and a vertex index within this line.

Note
Which line is selected is not of importance (and not exposed on purpose).

◆ standard_hex_vertex_to_quad_vertex_index()

static std::array< unsigned int, 2 > GeometryInfo< dim >::standard_hex_vertex_to_quad_vertex_index ( const unsigned int vertex)
static

Decompose the vertex index in a hex into a pair of a quad index and a vertex index within this quad.

Note
Which quad is selected is not of importance (and not exposed on purpose).

◆ standard_hex_line_to_quad_line_index()

static std::array< unsigned int, 2 > GeometryInfo< dim >::standard_hex_line_to_quad_line_index ( const unsigned int line)
static

Decompose the line index in a hex into a pair of a quad index and a line index within this quad.

Note
Which quad is selected is not of importance (and not exposed on purpose).

◆ real_to_standard_face_line()

static unsigned int GeometryInfo< dim >::real_to_standard_face_line ( const unsigned int line,
const bool face_orientation = true,
const bool face_flip = false,
const bool face_rotation = false )
static

Map the line index line of a face with arbitrary face_orientation, face_flip and face_rotation to a face in standard orientation. The values of these three flags default to true, false and false, respectively. this combination describes a face in standard orientation.

This function is only implemented in 3d.

◆ unit_cell_vertex()

static Point< dim > GeometryInfo< dim >::unit_cell_vertex ( const unsigned int vertex)
static

Return the position of the ith vertex on the unit cell. The order of vertices is the canonical one in deal.II, as described in the general documentation of this class.

◆ child_cell_from_point()

static unsigned int GeometryInfo< dim >::child_cell_from_point ( const Point< dim > & p)
static

Given a point p in unit coordinates, return the number of the child cell in which it would lie in. If the point lies on the interface of two children, return any one of their indices. The result is always less than GeometryInfo<dimension>::max_children_per_cell.

The order of child cells is described the general documentation of this class.

◆ cell_to_child_coordinates()

static Point< dim > GeometryInfo< dim >::cell_to_child_coordinates ( const Point< dim > & p,
const unsigned int child_index,
const RefinementCase< dim > refine_case = RefinementCase<dim>::isotropic_refinement )
static

Given coordinates p on the unit cell, return the values of the coordinates of this point in the coordinate system of the given child. Neither original nor returned coordinates need actually be inside the cell, we simply perform a scale-and-shift operation with a shift that depends on the number of the child.

◆ child_to_cell_coordinates()

static Point< dim > GeometryInfo< dim >::child_to_cell_coordinates ( const Point< dim > & p,
const unsigned int child_index,
const RefinementCase< dim > refine_case = RefinementCase<dim>::isotropic_refinement )
static

The reverse function to the one above: take a point in the coordinate system of the child, and transform it to the coordinate system of the mother cell.

◆ is_inside_unit_cell() [1/2]

static bool GeometryInfo< dim >::is_inside_unit_cell ( const Point< dim > & p)
static

Return true if the given point is inside the unit cell of the present space dimension.

◆ is_inside_unit_cell() [2/2]

static bool GeometryInfo< dim >::is_inside_unit_cell ( const Point< dim > & p,
const double eps )
static

Return true if the given point is inside the unit cell of the present space dimension. This function accepts an additional parameter which specifies how much the point position may actually be outside the true unit cell. This is useful because in practice we may often not be able to compute the coordinates of a point in reference coordinates exactly, but only up to numerical roundoff.

The tolerance parameter may be less than zero, indicating that the point should be safely inside the cell.

◆ project_to_unit_cell()

static Point< dim, Number > GeometryInfo< dim >::project_to_unit_cell ( const Point< dim, Number > & p)
static

Projects a given point onto the unit cell, i.e. each coordinate outside [0..1] is modified to lie within that interval.

◆ distance_to_unit_cell()

static double GeometryInfo< dim >::distance_to_unit_cell ( const Point< dim > & p)
static

Return the infinity norm of the vector between a given point p outside the unit cell to the closest unit cell boundary. For points inside the cell, this is defined as zero.

◆ d_linear_shape_function()

static double GeometryInfo< dim >::d_linear_shape_function ( const Point< dim > & xi,
const unsigned int i )
static

Compute the value of the $i$-th $d$-linear (i.e. (bi-,tri-)linear) shape function at location $\xi$.

◆ d_linear_shape_function_gradient()

static Tensor< 1, dim > GeometryInfo< dim >::d_linear_shape_function_gradient ( const Point< dim > & xi,
const unsigned int i )
static

Compute the gradient of the $i$-th $d$-linear (i.e. (bi-,tri-)linear) shape function at location $\xi$.

◆ alternating_form_at_vertices()

template void GeometryInfo< dim >::alternating_form_at_vertices ( const Point< spacedim >(&) vertices[vertices_per_cell],
Tensor< spacedim - dim, spacedim >(&) forms[vertices_per_cell] )
static

For a (bi-, tri-)linear mapping from the reference cell, face, or edge to the object specified by the given vertices, compute the alternating form of the transformed unit vectors vertices. For an object of dimensionality dim, there are dim vectors with spacedim components each, and the alternating form is a tensor of rank spacedim-dim that corresponds to the wedge product of the dim unit vectors, and it corresponds to the volume and normal vectors of the mapping from reference element to the element described by the vertices.

For example, if dim==spacedim==2, then the alternating form is a scalar (because spacedim-dim=0) and its value equals $\mathbf v_1\wedge \mathbf
v_2=\mathbf v_1^\perp \cdot\mathbf v_2$, where $\mathbf v_1^\perp$ is a vector that is rotated to the right by 90 degrees from $\mathbf v_1$. If dim==spacedim==3, then the result is again a scalar with value $\mathbf
v_1\wedge \mathbf v_2 \wedge \mathbf v_3 = (\mathbf v_1\times \mathbf
v_2)\cdot \mathbf v_3$, where $\mathbf v_1, \mathbf v_2, \mathbf v_3$ are the images of the unit vectors at a vertex of the unit dim-dimensional cell under transformation to the dim-dimensional cell in spacedim-dimensional space. In both cases, i.e. for dim==2 or 3, the result happens to equal the determinant of the Jacobian of the mapping from reference cell to cell in real space. Note that it is the actual determinant, not its absolute value as often used in transforming integrals from one coordinate system to another. In particular, if the object specified by the vertices is a parallelogram (i.e. a linear transformation of the reference cell) then the computed values are the same at all vertices and equal the (signed) area of the cell; similarly, for parallel-epipeds, it is the volume of the cell.

Likewise, if we have dim==spacedim-1 (e.g. we have a quad in 3d space, or a line in 2d), then the alternating product denotes the normal vector (i.e. a rank-1 tensor, since spacedim-dim=1) to the object at each vertex, where the normal vector's magnitude denotes the area element of the transformation from the reference object to the object given by the vertices. In particular, if again the mapping from reference object to the object under consideration here is linear (not bi- or trilinear), then the returned vectors are all parallel, perpendicular to the mapped object described by the vertices, and have a magnitude equal to the area/volume of the mapped object. If dim=1, spacedim=2, then the returned value is $\mathbf v_1^\perp$, where $\mathbf v_1$ is the image of the sole unit vector of a line mapped to the line in 2d given by the vertices; if dim=2, spacedim=3, then the returned values are $\mathbf v_1
\wedge \mathbf v_2=\mathbf v_1 \times \mathbf v_2$ where $\mathbf
v_1,\mathbf v_2$ are the two three-dimensional vectors that are tangential to the quad mapped into three-dimensional space.

This function is used in order to determine how distorted a cell is (see the entry on distorted cells in the glossary).

◆ ExcInvalidCoordinate()

static ::ExceptionBase & GeometryInfo< dim >::ExcInvalidCoordinate ( double arg1)
static

Exception

Note
The message that will be printed by this exception reads:
<< "The coordinates must satisfy 0 <= x_i <= 1, " << "but here we have x_i=" << arg1

◆ ExcInvalidSubface()

static ::ExceptionBase & GeometryInfo< dim >::ExcInvalidSubface ( int arg1,
int arg2,
int arg3 )
static

Exception

Note
The message that will be printed by this exception reads:
<< "RefinementCase<dim> " << arg1 << ": face " << arg2 << " has no subface " << arg3

Member Data Documentation

◆ max_children_per_cell [1/2]

unsigned int GeometryInfo< 0 >::max_children_per_cell = 1
staticconstexpr

Maximum number of children of a cell, i.e. the number of children of an isotropically refined cell.

If a cell is refined anisotropically, the actual number of children may be less than the value given here.

Definition at line 1241 of file geometry_info.h.

◆ faces_per_cell [1/2]

unsigned int GeometryInfo< 0 >::faces_per_cell = 0
staticconstexpr

Number of faces a cell has.

Definition at line 1246 of file geometry_info.h.

◆ max_children_per_face [1/2]

unsigned int GeometryInfo< 0 >::max_children_per_face = 0
staticconstexpr

Maximum number of children of a refined face, i.e. the number of children of an isotropically refined face.

If a cell is refined anisotropically, the actual number of children may be less than the value given here.

Definition at line 1274 of file geometry_info.h.

◆ vertices_per_cell [1/2]

unsigned int GeometryInfo< 0 >::vertices_per_cell = 1
staticconstexpr

Number of vertices a cell has.

Definition at line 1287 of file geometry_info.h.

◆ vertices_per_face [1/2]

unsigned int GeometryInfo< 0 >::vertices_per_face = 0
staticconstexpr

Number of vertices each face has. Since this is not useful in one dimension, we provide a useless number (in the hope that a compiler may warn when it sees constructs like for (i=0; i<vertices_per_face; ++i), at least if i is an unsigned int.

Definition at line 1367 of file geometry_info.h.

◆ lines_per_face [1/2]

unsigned int GeometryInfo< 0 >::lines_per_face = 0
staticconstexpr

Number of lines each face has.

Definition at line 1372 of file geometry_info.h.

◆ quads_per_face [1/2]

unsigned int GeometryInfo< 0 >::quads_per_face = 0
staticconstexpr

Number of quads on each face.

Definition at line 1377 of file geometry_info.h.

◆ lines_per_cell [1/2]

unsigned int GeometryInfo< 0 >::lines_per_cell = 0
staticconstexpr

Number of lines of a cell.

Definition at line 1382 of file geometry_info.h.

◆ quads_per_cell [1/2]

unsigned int GeometryInfo< 0 >::quads_per_cell = 0
staticconstexpr

Number of quadrilaterals of a cell.

Definition at line 1387 of file geometry_info.h.

◆ hexes_per_cell [1/2]

unsigned int GeometryInfo< 0 >::hexes_per_cell = 0
staticconstexpr

Number of hexahedra of a cell.

Definition at line 1392 of file geometry_info.h.

◆ ucd_to_deal [1/2]

const std::array<unsigned int, vertices_per_cell> GeometryInfo< 0 >::ucd_to_deal
static

Rearrange vertices for UCD output. For a cell being written in UCD format, each entry in this field contains the number of a vertex in deal.II that corresponds to the UCD numbering at this location.

Typical example: write a cell and arrange the vertices, such that UCD understands them.

for (i=0; i< n_vertices; ++i)
out << cell->vertex(ucd_to_deal[i]);
static const std::array< unsigned int, vertices_per_cell > ucd_to_deal

As the vertex numbering in deal.II versions <= 5.1 happened to coincide with the UCD numbering, this field can also be used like a old_to_lexicographic mapping.

Definition at line 1411 of file geometry_info.h.

◆ dx_to_deal [1/2]

const std::array<unsigned int, vertices_per_cell> GeometryInfo< 0 >::dx_to_deal
static

Rearrange vertices for OpenDX output. For a cell being written in OpenDX format, each entry in this field contains the number of a vertex in deal.II that corresponds to the DX numbering at this location.

Typical example: write a cell and arrange the vertices, such that OpenDX understands them.

for (i=0; i< n_vertices; ++i)
out << cell->vertex(dx_to_deal[i]);
static const std::array< unsigned int, vertices_per_cell > dx_to_deal

Definition at line 1426 of file geometry_info.h.

◆ max_children_per_cell [2/2]

unsigned int GeometryInfo< dim >::max_children_per_cell
staticconstexpr

Maximum number of children of a refined cell, i.e. the number of children of an isotropically refined cell.

If a cell is refined anisotropically, the actual number of children may be less than the value given here.

Definition at line 1972 of file geometry_info.h.

◆ faces_per_cell [2/2]

unsigned int GeometryInfo< dim >::faces_per_cell
staticconstexpr

Number of faces of a cell.

Definition at line 1977 of file geometry_info.h.

◆ max_children_per_face [2/2]

unsigned int GeometryInfo< dim >::max_children_per_face
staticconstexpr

Maximum number of children of a refined face, i.e. the number of children of an isotropically refined face.

If a cell is refined anisotropically, the actual number of children may be less than the value given here.

Definition at line 2005 of file geometry_info.h.

◆ vertices_per_cell [2/2]

unsigned int GeometryInfo< dim >::vertices_per_cell
staticconstexpr

Number of vertices of a cell.

Definition at line 2011 of file geometry_info.h.

◆ vertices_per_face [2/2]

unsigned int GeometryInfo< dim >::vertices_per_face
staticconstexpr

Number of vertices on each face.

Definition at line 2034 of file geometry_info.h.

◆ lines_per_face [2/2]

unsigned int GeometryInfo< dim >::lines_per_face
staticconstexpr

Number of lines on each face.

Definition at line 2040 of file geometry_info.h.

◆ quads_per_face [2/2]

unsigned int GeometryInfo< dim >::quads_per_face
staticconstexpr

Number of quads on each face.

Definition at line 2046 of file geometry_info.h.

◆ lines_per_cell [2/2]

unsigned int GeometryInfo< dim >::lines_per_cell
staticconstexpr

Number of lines of a cell.

The formula to compute this makes use of the fact that when going from one dimension to the next, the object of the lower dimension is copied once (thus twice the old number of lines) and then a new line is inserted between each vertex of the old object and the corresponding one in the copy.

Definition at line 2058 of file geometry_info.h.

◆ quads_per_cell [2/2]

unsigned int GeometryInfo< dim >::quads_per_cell
staticconstexpr

Number of quadrilaterals of a cell.

This number is computed recursively just as the previous one, with the exception that new quads result from connecting an original line and its copy.

Definition at line 2069 of file geometry_info.h.

◆ hexes_per_cell [2/2]

unsigned int GeometryInfo< dim >::hexes_per_cell
staticconstexpr

Number of hexahedra of a cell.

Definition at line 2076 of file geometry_info.h.

◆ ucd_to_deal [2/2]

std::array<unsigned int, vertices_per_cell> GeometryInfo< dim >::ucd_to_deal
staticconstexpr

Rearrange vertices for UCD output. For a cell being written in UCD format, each entry in this field contains the number of a vertex in deal.II that corresponds to the UCD numbering at this location.

Typical example: write a cell and arrange the vertices, such that UCD understands them.

for (i=0; i< n_vertices; ++i)
out << cell->vertex(ucd_to_deal[i]);

As the vertex numbering in deal.II versions <= 5.1 happened to coincide with the UCD numbering, this field can also be used like a old_to_lexicographic mapping.

Definition at line 2097 of file geometry_info.h.

◆ dx_to_deal [2/2]

std::array<unsigned int, vertices_per_cell> GeometryInfo< dim >::dx_to_deal
staticconstexpr

Rearrange vertices for OpenDX output. For a cell being written in OpenDX format, each entry in this field contains the number of a vertex in deal.II that corresponds to the DX numbering at this location.

Typical example: write a cell and arrange the vertices, such that OpenDX understands them.

for (i=0; i< n_vertices; ++i)
out << cell->vertex(dx_to_deal[i]);

Definition at line 2113 of file geometry_info.h.

◆ vertex_to_face

ndarray<unsigned int, vertices_per_cell, dim> GeometryInfo< dim >::vertex_to_face
staticconstexpr

This field stores for each vertex to which faces it belongs. In any given dimension, the number of faces is equal to the dimension. The first index in this 2d-array runs over all vertices, the second index over dim faces to which the vertex belongs.

The order of the faces for each vertex is such that the first listed face bounds the reference cell in x direction, the second in y direction, and so on.

Definition at line 2127 of file geometry_info.h.

◆ unit_normal_direction

std::array<unsigned int, faces_per_cell> GeometryInfo< dim >::unit_normal_direction
staticconstexpr

For each face of the reference cell, this field stores the coordinate direction in which its normal vector points. In dim dimension these are the 2*dim first entries of {0,0,1,1,2,2,3,3}.

Note that this is only the coordinate number. The actual direction of the normal vector is obtained by multiplying the unit vector in this direction with unit_normal_orientation.

Definition at line 2579 of file geometry_info.h.

◆ unit_normal_orientation

std::array<int, faces_per_cell> GeometryInfo< dim >::unit_normal_orientation
staticconstexpr

Orientation of the unit normal vector of a face of the reference cell. In dim dimension these are the 2*dim first entries of {-1,1,-1,1,-1,1,-1,1}.

Each value is either 1 or -1, corresponding to a normal vector pointing in the positive or negative coordinate direction, respectively.

Note that this is only the standard orientation of faces. At least in 3d, actual faces of cells in a triangulation can also have the opposite orientation, depending on a flag that one can query from the cell it belongs to. For more information, see the glossary entry on face orientation.

Definition at line 2598 of file geometry_info.h.

◆ unit_normal_vector

std::array<Tensor<1, dim>, faces_per_cell> GeometryInfo< dim >::unit_normal_vector
staticconstexpr

Unit normal vector (Point<dim>) of a face of the reference cell.

Note that this is only the standard orientation of faces. At least in 3d, actual faces of cells in a triangulation can also have the opposite orientation, depending on a flag that one can query from the cell it belongs to. For more information, see the glossary entry on face orientation.

Definition at line 2612 of file geometry_info.h.

◆ unit_tangential_vectors

ndarray<Tensor<1, dim>, faces_per_cell, dim - 1> GeometryInfo< dim >::unit_tangential_vectors
staticconstexpr

Unit tangential vectors (array of dim-1 elements of Point<dim>) of a face of the reference cell, arranged in a right-hand coordinate system such that the cross product between the two vectors return the unit normal vector.

Note that this is only the standard orientation of faces. At least in 3d, actual faces of cells in a triangulation can also have the opposite orientation, depending on a flag that one can query from the cell it belongs to. For more information, see the glossary entry on face orientation.

Definition at line 2629 of file geometry_info.h.

◆ opposite_face

std::array<unsigned int, faces_per_cell> GeometryInfo< dim >::opposite_face
staticconstexpr

List of numbers which denotes which face is opposite to a given face. Its entries are the first 2*dim entries of { 1, 0, 3, 2, 5, 4, 7, 6}.

Definition at line 2637 of file geometry_info.h.


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