Data Structures | Functions

viennagrid::detail Namespace Reference

The namespace holding the implementations of domains, segments and ncells as well as some algorithm implementations. Not of interest for library users. More...

Data Structures

struct  cross_prod_impl< PointType, 1 >
 Implementation of the cross product calculation in 1d for compatibility. Returns the zero-vector. More...
struct  cross_prod_impl< PointType, 2 >
 Implementation of the cross product calculation in 2d for compatibility. Returns the zero-vector. More...
struct  cross_prod_impl< PointType, 3 >
 Implementation of the cross product calculation in 3d. More...
struct  inner_prod_impl< PointType, 1 >
 Implementation of the inner product in one dimension. More...
struct  inner_prod_impl< PointType, 2 >
 Implementation of the inner product in two dimensions. More...
struct  inner_prod_impl< PointType, 3 >
 Implementation of the inner product in three dimensions. More...
struct  norm_impl
struct  norm_impl< viennagrid::one_tag >
 Implementation of the 1-norm. More...
struct  norm_impl< viennagrid::two_tag >
 Implementation of the 2-norm. More...
struct  norm_impl< viennagrid::inf_tag >
 Implementation of the inf-norm. More...
struct  refinement_vertex_id_requirement
 Refinement requies vertex IDs. This class makes sure that they are available. More...
struct  refinement_vertex_id_requirement< DomainType, pointer_id >
struct  spanned_volume_impl< PointType, 1 >
 Implementation of the volume spanned by two points in one dimension. More...
struct  spanned_volume_impl< PointType, 2 >
 Implementation of the volume of simplices spanned by points in two geometrical dimension. More...
struct  spanned_volume_impl< PointType, 3 >
 Implementation of the volume of simplices spanned by points in three geometrical dimension. More...
class  domain_segment_container
 Class responsible for holding the segments inside a domain. More...
class  domain_layers
 Class holding all n-cells of a particular topological dimension n. Uses recursive inheritance similar to n-cells themselves. More...
class  domain_layers< Config, dim, false, no_handling_tag >
 Specialization of a domin layer without the storage of n-cells. More...
class  domain_layers< Config, dim, true, full_handling_tag >
 Specialization for the cell level. More...
class  domain_layers< Config, 0, is_cell, STOR >
 Specialization for the vertex level. Terminates the recursive inheritance. More...
struct  id_ptr_compare
 Helper class for comparing the ID of n-cells, for which only the pointers are available. Used as comparison in std::map. More...
class  segment_domain_holder
 Class that holds a reference to the domain the segment belongs to. More...
struct  next_segment_layer_selector
 Helper class that returns the next class type for recursive inheritance. Was introduced due to Visual Studio compilation problems of the first approach. More...
struct  next_segment_layer_selector< Config, dim, no_handling_tag >
struct  next_segment_layer_selector< Config, 0, handling_tag >
class  segment_layers_full
 Full handling of a particular topological dimension of a segment. More...
class  segment_layers_full< Config, 0 >
 Specialization of full handling at vertex level. Terminates recursion. More...
class  segment_layers_empty
 No handling of elements by cells on that level. Therefore, don't handle it within segments as well. Uses recursive inheritance. More...
class  segment_layers_top
 Handler for cells in a segment. Since cells are the defining entity of segments, this requires special treatment. More...

Functions

template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::triangle_tag)
 Implementation of the calculation of a centroid for a triangle.
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::tetrahedron_tag)
 Implementation of the calculation of a centroid for a tetrahedron.
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::quadrilateral_tag)
 Implementation of the calculation of a centroid for a quadrilateral.
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::hexahedron_tag)
 Implementation of the calculation of a centroid for a hexahedron.
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::simplex_tag< 1 >)
 Implementation of the calculation of a centroid for a line (1-simplex).
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::hypercube_tag< 1 >)
 Implementation of the calculation of a centroid for a line (1-hypercube).
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
centroid (ElementType const &cell, viennagrid::point_tag)
 Implementation of the calculation of a centroid for a point.
template<typename DomainSegmentType >
viennagrid::result_of::point
< typename
DomainSegmentType::config_type >
::type 
centroid_domseg (DomainSegmentType const &domseg)
template<typename ElementType , typename ElementTag , typename DimensionTag >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, ElementTag const &, DimensionTag const &)
 Throws a compile time error if the n-cell type is not supported.
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::point_tag)
 Implementation of the calculation of a circumcenter for a point (degenerate case).
template<typename ElementType , typename DimensionTag >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::simplex_tag< 1 >, DimensionTag)
 Implementation of the calculation of a circumcenter for a line (1-simplex).
template<typename ElementType , typename DimensionTag >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::hypercube_tag< 1 >, DimensionTag)
 Implementation of the calculation of a circumcenter for a line (1-hypercube).
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::triangle_tag, viennagrid::dimension_tag< 2 >)
 Implementation of the calculation of a circumcenter for a triangle in two dimensions.
template<typename CellType >
viennagrid::result_of::point
< typename
CellType::config_type >::type 
circumcenter (CellType const &cell, viennagrid::quadrilateral_tag, viennagrid::dimension_tag< 2 >)
 Implementation of the calculation of a circumcenter for a quadrilateral in two dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::triangle_tag, viennagrid::dimension_tag< 3 >)
 Implementation of the calculation of a circumcenter for a triangle in three dimensions.
template<typename CellType >
viennagrid::result_of::point
< typename
CellType::config_type >::type 
circumcenter (CellType const &cell, viennagrid::quadrilateral_tag, viennagrid::dimension_tag< 3 >)
 Implementation of the calculation of a circumcenter for a quadrilateral in three dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!
template<typename ElementType >
viennagrid::result_of::point
< typename
ElementType::config_type >
::type 
circumcenter (ElementType const &cell, viennagrid::tetrahedron_tag, viennagrid::dimension_tag< 3 >)
 Implementation of the calculation of a circumcenter for a tetrahedron in three dimensions.
template<typename CellType >
viennagrid::result_of::point
< typename
CellType::config_type >::type 
circumcenter (CellType const &cell, viennagrid::hexahedron_tag, viennagrid::dimension_tag< 3 >)
 Implementation of the calculation of a circumcenter for a hexahedron in three dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!
template<typename ConfigTypeIn >
void ensure_longest_edge_refinement (domain_t< ConfigTypeIn > const &domain_in)
 Ensures refinement fo the longest edge. If any edge is refined in a cell, then the longest edge is refined as well.
template<typename ConfigTypeIn >
void cell_refinement_to_edge_refinement (domain_t< ConfigTypeIn > const &domain_in)
 Transfers tags for refinement from the cell to edges.
template<typename ConfigTypeIn , typename ConfigTypeOut >
void refine_impl (domain_t< ConfigTypeIn > const &domain_in, domain_t< ConfigTypeOut > &domain_out, local_refinement_tag)
 Implementation of adaptive refinement. Responsible for all the book-keeping.
template<typename ConfigTypeIn , typename ConfigTypeOut >
void refine_impl (domain_t< ConfigTypeIn > const &domain_in, domain_t< ConfigTypeOut > &domain_out, uniform_refinement_tag)
 Implementation of uniform refinement. Responsible for all the book-keeping.
template<typename ContainerType >
ContainerType::config_type::numeric_type surface_domainsegment (ContainerType const &d)
 Implementation for the calculation of the surface of a domain or segment.
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::point_tag)
 Computes the volume of topologically zero-dimensional elements (vertices). Degenerate case, returns 1.
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::simplex_tag< 1 >)
 Computes the volume of topologically one-dimensional elements (lines, 1-simplex).
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::hypercube_tag< 1 >)
 Computes the volume of topologically one-dimensional elements (lines, 1-hypercube).
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::triangle_tag)
 Computes the two-dimensional volume of a triangle.
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::quadrilateral_tag)
 Computes the two-dimensional volume of a quadrilateral.
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::tetrahedron_tag)
 Computes the three-dimensional volume of a tetrahedron.
template<typename ElementType >
ElementType::config_type::numeric_type volume_impl (ElementType const &cell, viennagrid::hexahedron_tag)
 Computes the three-dimensional volume of a hexahedron.
template<typename ContainerType >
ContainerType::config_type::numeric_type volume_domainsegment (ContainerType const &d)
 Dispatched function for computing the volume of a domain or segment.
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::simplex_tag< 1 >)
 Implementation of the computation of Voronoi quantities for a one-dimensional domain (line, 1-simplex).
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::hypercube_tag< 1 >)
 Implementation of the computation of Voronoi quantities for a one-dimensional domain (line, 1-hypercube).
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::quadrilateral_tag)
 Implementation of the computation of Voronoi quantities for a quadrilateral domain.
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::triangle_tag)
 Implementation of the computation of Voronoi quantities for a triangular domain.
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::tetrahedron_tag)
 Implementation of the computation of Voronoi quantities for a tetrahedral domain.
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void write_voronoi_info (DomainType const &domain, InterfaceAreaKey const &interface_key, BoxVolumeKey const &box_volume_key, viennagrid::hexahedron_tag)
 Implementation of the computation of Voronoi quantities for a hexahedral domain.

Detailed Description

The namespace holding the implementations of domains, segments and ncells as well as some algorithm implementations. Not of interest for library users.


Function Documentation

void viennagrid::detail::cell_refinement_to_edge_refinement ( domain_t< ConfigTypeIn > const &  domain_in  ) 

Transfers tags for refinement from the cell to edges.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::triangle_tag   
)

Implementation of the calculation of a centroid for a triangle.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::hexahedron_tag   
)

Implementation of the calculation of a centroid for a hexahedron.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::tetrahedron_tag   
)

Implementation of the calculation of a centroid for a tetrahedron.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::simplex_tag< 1 >   
)

Implementation of the calculation of a centroid for a line (1-simplex).

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::quadrilateral_tag   
)

Implementation of the calculation of a centroid for a quadrilateral.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::hypercube_tag< 1 >   
)

Implementation of the calculation of a centroid for a line (1-hypercube).

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::centroid ( ElementType const &  cell,
viennagrid::point_tag   
)

Implementation of the calculation of a centroid for a point.

viennagrid::result_of::point<typename DomainSegmentType::config_type>::type viennagrid::detail::centroid_domseg ( DomainSegmentType const &  domseg  ) 
viennagrid::result_of::point<typename CellType::config_type>::type viennagrid::detail::circumcenter ( CellType const &  cell,
viennagrid::quadrilateral_tag  ,
viennagrid::dimension_tag< 3 >   
)

Implementation of the calculation of a circumcenter for a quadrilateral in three dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::tetrahedron_tag  ,
viennagrid::dimension_tag< 3 >   
)

Implementation of the calculation of a circumcenter for a tetrahedron in three dimensions.

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
ElementTag const &  ,
DimensionTag const &   
)

Throws a compile time error if the n-cell type is not supported.

viennagrid::result_of::point<typename CellType::config_type>::type viennagrid::detail::circumcenter ( CellType const &  cell,
viennagrid::hexahedron_tag  ,
viennagrid::dimension_tag< 3 >   
)

Implementation of the calculation of a circumcenter for a hexahedron in three dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::point_tag   
)

Implementation of the calculation of a circumcenter for a point (degenerate case).

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::simplex_tag< 1 >  ,
DimensionTag   
)

Implementation of the calculation of a circumcenter for a line (1-simplex).

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::hypercube_tag< 1 >  ,
DimensionTag   
)

Implementation of the calculation of a circumcenter for a line (1-hypercube).

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::triangle_tag  ,
viennagrid::dimension_tag< 2 >   
)

Implementation of the calculation of a circumcenter for a triangle in two dimensions.

viennagrid::result_of::point<typename CellType::config_type>::type viennagrid::detail::circumcenter ( CellType const &  cell,
viennagrid::quadrilateral_tag  ,
viennagrid::dimension_tag< 2 >   
)

Implementation of the calculation of a circumcenter for a quadrilateral in two dimensions. Mind that the user has to ensure that the quadrilateral actually has a circumcenter!

viennagrid::result_of::point<typename ElementType::config_type>::type viennagrid::detail::circumcenter ( ElementType const &  cell,
viennagrid::triangle_tag  ,
viennagrid::dimension_tag< 3 >   
)

Implementation of the calculation of a circumcenter for a triangle in three dimensions.

void viennagrid::detail::ensure_longest_edge_refinement ( domain_t< ConfigTypeIn > const &  domain_in  ) 

Ensures refinement fo the longest edge. If any edge is refined in a cell, then the longest edge is refined as well.

void refine_impl ( domain_t< ConfigTypeIn > const &  domain_in,
domain_t< ConfigTypeOut > &  domain_out,
local_refinement_tag   
)

Implementation of adaptive refinement. Responsible for all the book-keeping.

void refine_impl ( domain_t< ConfigTypeIn > const &  domain_in,
domain_t< ConfigTypeOut > &  domain_out,
uniform_refinement_tag   
)

Implementation of uniform refinement. Responsible for all the book-keeping.

ContainerType::config_type::numeric_type viennagrid::detail::surface_domainsegment ( ContainerType const &  d  ) 

Implementation for the calculation of the surface of a domain or segment.

ContainerType::config_type::numeric_type viennagrid::detail::volume_domainsegment ( ContainerType const &  d  ) 

Dispatched function for computing the volume of a domain or segment.

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::hexahedron_tag   
)

Computes the three-dimensional volume of a hexahedron.

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::triangle_tag   
)

Computes the two-dimensional volume of a triangle.

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::tetrahedron_tag   
)

Computes the three-dimensional volume of a tetrahedron.

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::simplex_tag< 1 >   
)

Computes the volume of topologically one-dimensional elements (lines, 1-simplex).

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::hypercube_tag< 1 >   
)

Computes the volume of topologically one-dimensional elements (lines, 1-hypercube).

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::point_tag   
)

Computes the volume of topologically zero-dimensional elements (vertices). Degenerate case, returns 1.

ElementType::config_type::numeric_type viennagrid::detail::volume_impl ( ElementType const &  cell,
viennagrid::quadrilateral_tag   
)

Computes the two-dimensional volume of a quadrilateral.

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::quadrilateral_tag   
)

Implementation of the computation of Voronoi quantities for a quadrilateral domain.

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::tetrahedron_tag   
)

Implementation of the computation of Voronoi quantities for a tetrahedral domain.

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::hexahedron_tag   
)

Implementation of the computation of Voronoi quantities for a hexahedral domain.

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::triangle_tag   
)

Implementation of the computation of Voronoi quantities for a triangular domain.

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::hypercube_tag< 1 >   
)

Implementation of the computation of Voronoi quantities for a one-dimensional domain (line, 1-hypercube).

void viennagrid::detail::write_voronoi_info ( DomainType const &  domain,
InterfaceAreaKey const &  interface_key,
BoxVolumeKey const &  box_volume_key,
viennagrid::simplex_tag< 1 >   
)

Implementation of the computation of Voronoi quantities for a one-dimensional domain (line, 1-simplex).