Namespaces | Data Structures | Typedefs | Functions

viennagrid Namespace Reference

The main ViennaGrid namespace. Most functionality resides in this namespace. More...

Namespaces

namespace  config
 

Provides a number of predefined configuration classes, which cover the most frequent use cases.


namespace  detail
 

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


namespace  io
 

A namespace with all the input/output functionality, in particular file readers and writers.


namespace  result_of
 

The metafunction layer. Provides type generators that derive the respective type from the domain configuration.


namespace  topology
 

Namespace for definition and handling of the individual topological elements (triangles, hexahedra, etc.).


namespace  traits
 

A generic layer for accessing containers such as std::vector, std::deque, std::map, etc.


Data Structures

class  boundary_key
 A key type for storing boundary information on n-cells, segments and domains. More...
class  boundary_key< element_t< ConfigType, ElementTag > >
 Specialization for n-cells. More...
class  boundary_key< segment_t< ConfigType > >
 Specialization for segments. More...
class  boundary_key< domain_t< ConfigType > >
 Specialization for domains. More...
struct  boundary_setter
 Helper struct for setting boundary flag of lower level elements of a facet. More...
struct  boundary_setter< -1 >
 Ends the recursion below the vertex level. More...
class  interface_key
 A key used for ViennaData in order to store interface information. More...
struct  interface_setter
 Helper struct for setting interface flag of boundary k-cells of a facet. More...
struct  interface_setter< -1 >
 Specialization that stops recursion below the vertex level. More...
class  refinement_proxy
 A proxy class that is used to allow ' refined_domain = refine(domain); ' without temporary. More...
class  boundary_ncell_layer
 A class holding all information about boundary k-cells of a n-cell. More...
class  boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, full_handling_tag, false >
 Implementation of full storage of k-cells including orientations. More...
class  boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, no_handling_tag, false >
 Implementation of boundary k-cell storage without orientation. More...
class  boundary_ncell_layer< ConfigType, ElementTag, dim, no_handling_tag, orienter_tag, false >
 Implementation of the case that boundary k-cells are not stored at all. More...
class  boundary_ncell_layer< ConfigType, ElementTag, 0, handling_tag, orienter_tag, true >
 Specialization for the vertex level. Recursion ends here. More...
class  domain_subcell_iterator
 Iterator over non-vertices and non-cells on a domain. More...
struct  domain_iterators
 Helper for iterator construction for iteration over the whole domain. More...
struct  domain_iterators< Config, 0, cell_level >
 Helper for iterator construction for vertex iteration over the whole domain. More...
struct  domain_iterators< Config, cell_level, cell_level >
 Helper for iterator construction for cell iteration over the whole domain. More...
struct  assert_bracket_operator_access
 A guard that ensures that operator[] access is possible. Throws a verbose compile time error if access is not possible. More...
struct  assert_bracket_operator_access< std::vector< ElementType > >
 Specialization: Allow operator[] if the underlying container is a std::vector<> More...
struct  assert_bracket_operator_access< std::deque< ElementType > >
 Specialization: Allow operator[] if the underlying container is a std::deque<> More...
class  ncell_range< domain_t< config_type >, dim, false >
 Main range class. Specialization for use with iteration or access to k-cells on the domain. More...
class  const_ncell_range< domain_t< config_type >, dim, false >
 Main const-range class. Specialization for use with const-iteration or access to k-cells on the domain. More...
class  on_element_iterator
 Iterator class for iterating over a range of elements given by a container of pointers. More...
class  const_on_element_iterator
 Iterator class for const iteration over a range of elements given by a container of pointers. More...
struct  ElementIteratorChecker
 A helper class that checks whether a certain iterator is available. More...
struct  ElementIteratorChecker< ElementTag, level, full_handling_tag >
 Specialization for an available iterator. More...
struct  IteratorChecker
 Class that checks the validity of the requested iterator. More...
struct  IteratorChecker< element_t< Config, ElementTag >, level >
 Class that checks the validity of the requested iterator. More...
class  ncell_range< element_t< config_type, tag >, dim, false >
 The main non-const range object for iteration or direct access of boundary k-cells of a n-cell. More...
class  const_ncell_range< element_t< config_type, tag >, dim, false >
 The main const range object for iteration or direct access of boundary k-cells of a n-cell. More...
class  cobnd_proxy
 A proxy object for cheaper setup of range objects using the ncells<>() function. More...
class  ncell_range< element_t< config_type, tag >, dim, true >
 The range class for non-const iteration and access of coboundary k-cells of a n-cell, k>n. More...
class  const_cobnd_proxy
 A proxy object for cheaper setup of range objects using the ncells<>() function. More...
class  const_ncell_range< element_t< config_type, tag >, dim, true >
 The range class for const iteration and access of coboundary k-cells of a n-cell, k>n. More...
struct  ElementKeyStorageType
 Internal helper class: holds an ordered number of vertices. Comparisons also take permutations into account. More...
struct  ElementKeyStorageType< ConfigType, ElementType, integral_id >
class  element_key
 A key type that uniquely identifies an element by its vertices. More...
class  element_orientation
 A permutator for mapping local orientations to global vertices of a boundary k-cell. More...
class  on_segment_iterator
 Iterator for non-const iteration over n-cells of a segment. More...
class  const_on_segment_iterator
 Iterator for const iteration over n-cells of a segment. More...
struct  segment_iterators< Config, cell_level, cell_level >
 Segment iterator type retrieval for cells. More...
class  ncell_range< segment_t< config_type >, dim, false >
 Main range class (non-const). Specialization for use with iteration or access to k-cells of a segment. More...
class  const_ncell_range< segment_t< config_type >, dim, false >
 Main const-range class. Specialization for use with const iteration or const access to k-cells of a segment. More...
class  domain_t
 The domain class. Assembled at compile time by recursive inheritance for each topological level by the detail::domain_layers class. More...
class  element_t
 The main n-cell class. Assembled by recursive inheritance. More...
class  element_t< ConfigType, point_tag >
 Specialization of the main n-cell class for vertices. Does not need to do any recursive inheritance here. More...
struct  dimension_tag
 A helper tag for dispatches based on the geometrical or topological dimension. More...
struct  full_handling_tag
 A tag denoting full storage of (boundary) k-cells of a certain topological dimension. More...
struct  no_handling_tag
 A tag denoting that the (boundary) k-cells should not be stored. More...
class  coboundary_key
 A key used for ViennaData to store coboundary information on n-cells. More...
class  segment_mapping_key
class  const_ncell_proxy
 A proxy class for retrieving const n-cell ranges. More...
class  ncell_proxy
 A proxy class for retrieving n-cell ranges. More...
class  pointer_id
 ID handler class for IDs based on the n-cell address. More...
class  integral_id
 ID handler class for IDs of type long. Has to be used for dense quantity storage with ViennaData. More...
struct  one_tag
 Tag for denoting the 1-norm. More...
struct  two_tag
 Tag for denoting the 2-norm. More...
struct  inf_tag
 Tag for denoting the infinity-norm. More...
struct  seg_cell_normal_tag
 Types for cell normals in algorithm/cell_normals.hpp (to be added in afuture release). More...
struct  seg_cell_normal_data
 Data type for cell normals in algorithm/cell_normals.hpp (to be added in afuture release). More...
struct  refinement_key
 A key type used for tagging edges for refinement using ViennaData. More...
struct  uniform_refinement_tag
 A tag denoting uniform refinement. More...
struct  local_refinement_tag
 A tag denoting local refinement. More...
struct  voronoi_interface_area_key
 ViennaData key for the Voronoi interface area associated with an edge. More...
struct  voronoi_box_volume_key
 ViennaData key for the Voronoi box volume associated with an edge or vertex. More...
class  coordinate_converter
 A conversion facility for transformations between coordinate systems. More...
class  coordinate_converter< FromPointType, ToPointType, cartesian_cs< 2 >, polar_cs >
 A functor for the transformation from two-dimensional Cartesian coordinates to polar coodinates. More...
class  coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, spherical_cs >
 A functor for the transformation from three-dimensional Cartesian coordinates to spherical coodinates. More...
class  coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, cylindrical_cs >
 A functor for the transformation from three-dimensional Cartesian coordinates to cylindrical coodinates. More...
class  coordinate_converter< FromPointType, ToPointType, polar_cs, cartesian_cs< 2 > >
 A functor for the transformation from polar coordinates to two-dimensional Cartesian coordinates. More...
class  coordinate_converter< FromPointType, ToPointType, spherical_cs, cartesian_cs< 3 > >
 A functor for the transformation from spherical coodinates to three-dimensional Cartesian coordinates. More...
class  coordinate_converter< FromPointType, ToPointType, spherical_cs, cylindrical_cs >
 A functor for the transformation from spherical coodinates to cylindrical coordinates. More...
class  coordinate_converter< FromPointType, ToPointType, cylindrical_cs, cartesian_cs< 3 > >
 A functor for the transformation from cylindrical coodinates to three-dimensional Cartesian coordinates. More...
class  coordinate_converter< FromPointType, ToPointType, cylindrical_cs, spherical_cs >
 A functor for the transformation from cylindrical coordinates to spherical coodinates. More...
struct  cartesian_cs
 Provides the basic operations in a cartesian coordinate system. More...
struct  cs_base
 Common base for all non-cartesian coordinate systems. More...
struct  polar_cs
 Provides the basic operations in a polar coordinate system (r, phi). More...
struct  spherical_cs
 Provides the basic operations in a spherical coordinate system (r, theta, phi) with theta denoting the elevation angle. More...
struct  cylindrical_cs
 Provides the basic operations in a cylindrical coordinate system (rho, theta, z). More...
class  point_index_out_of_bounds_exception
 An exception class for invalid point indices. More...
struct  point_filler
 A helper class for filling point coordinates with values. More...
struct  point_filler< CoordType, 1 >
 A helper class for filling point coordinates with values. Specialization for one dimension. More...
struct  point_filler< CoordType, 2 >
 A helper class for filling point coordinates with values. Specialization for two dimensions. More...
struct  point_filler< CoordType, 3 >
 A helper class for filling point coordinates with values. Specialization for three dimensions. More...
class  point_t
 Represents an arbitrary point in the underlying coordinate system. More...
struct  point_less
 This class provides a less-than comparison for points. Entries are checked for inequality, starting from the first and continuing only in the case of equality. More...
class  segment_t
struct  hypercube_tag< 3 >
 A hypercube of dimension 3, aka. hexahedron. More...
struct  simplex_tag< 1 >
 Topological description of a 1-cell (line). Same as hypercube_tag<1>. More...
struct  hypercube_tag< 1 >
 Topological description of a 1-cell (line). Same as simplex_tag<1>. More...
struct  point_tag
 Topological description of a 0-cell (vertex). More...
struct  hypercube_tag< 2 >
 Topological description of a quadrilateral. More...
struct  simplex_tag< 3 >
 Topological description of a tetrahedron. More...
struct  element_refinement< tetrahedron_tag >
 Class specialization for the refinement of a tetrahedron: A LOT of spaghetti-code to follow. More...
struct  simplex_tag< 2 >
 Topological description of a triangle. More...
struct  element_refinement< triangle_tag >
 Specialization of the refinement class for a triangle. More...

Typedefs

typedef std::size_t dim_type
 A global size_type equivalent for use throughout ViennaData.
typedef simplex_tag< 1 > line_tag
 Convenience type definition for a line.
typedef simplex_tag< 2 > triangle_tag
 Convenience type definition for a triangle.
typedef simplex_tag< 3 > tetrahedron_tag
 Convenience type definition for a tetrahedron.
typedef hypercube_tag< 2 > quadrilateral_tag
 Convenience type definition for a quadrilateral.
typedef hypercube_tag< 3 > hexahedron_tag
 Convenience type definition for a hexahedron.

Functions

template<typename DomainSegmentType , typename KeyType >
void detect_boundary_impl (DomainSegmentType const &seg, KeyType const &key, no_handling_tag)
 Implementation of boundary detection for the case no facets are available. Issues a hopefully useful compiler error.
template<typename DomainSegmentType , typename KeyType >
void detect_boundary_impl (DomainSegmentType const &seg, KeyType const &key, full_handling_tag)
 Implementation of boundary detection. Should not be called by library users.
template<typename DomainSegmentType , typename KeyType >
void detect_boundary (DomainSegmentType const &segment, KeyType const &key)
 Public interface functions for boundary detection. No need to call it explicitly, since it is called by is_boundary().
template<typename ConfigType , typename ElementTag >
bool is_boundary (element_t< ConfigType, ElementTag > const &el, domain_t< ConfigType > const &domain)
 Returns true if a n-cell is located on the boundary of the domain.
template<typename ConfigType , typename ElementTag >
bool is_boundary (element_t< ConfigType, ElementTag > const &el, segment_t< ConfigType > const &segment)
 Returns true if a n-cell is located on the boundary of a segment.
template<typename CellType >
viennagrid::result_of::point
< typename
CellType::config_type >::type 
centroid (CellType const &cell)
 The public interface function for the computation of a centroid.
template<typename ConfigType >
viennagrid::result_of::point
< ConfigType >::type 
centroid (domain_t< ConfigType > const &domain)
 The public interface function for the computation of the centroid of a domain.
template<typename ConfigType >
viennagrid::result_of::point
< ConfigType >::type 
centroid (segment_t< ConfigType > const &segment)
 The public interface function for the computation of the centroid of a segment.
template<typename CellType >
viennagrid::result_of::point
< typename
CellType::config_type >::type 
circumcenter (CellType const &cell)
 The public interface function for the calculation of the circumcenter.
template<typename PointType1 , typename PointType2 , typename CSystem1 , typename CSystem2 >
PointType1 cross_prod_impl (PointType1 const &p1, PointType2 const &p2, CSystem1 const &, CSystem2 const &)
 Dispatched cross product function having information about the coordinate systems. Transforms to Cartesian coordinates and forwards to calculation.
template<typename PointType1 , typename PointType2 , long d>
PointType1 cross_prod_impl (PointType1 const &p1, PointType2 const &p2, cartesian_cs< d >, cartesian_cs< d >)
 Dispatched cross product function having information about the coordinate systems. Points are already in Cartesian coordinates, thus forwarding to the worker function directly.
template<typename PointType1 , typename PointType2 >
PointType1 cross_prod (PointType1 const &v1, PointType2 const &v2)
 Returns the cross product of two vectors. If the vectors have one or two components only, the zero vector is returned.
template<typename PointType1 , typename PointType2 , typename CSystem1 , typename CSystem2 >
traits::value_type< PointType1 >
::type 
inner_prod_impl (PointType1 const &p1, PointType2 const &p2, CSystem1 const &, CSystem2 const &)
 Dispatched inner product function having full information about the coordinate systems. Transforms to Cartesian coordinates and forwards the calculation to the worker.
template<typename PointType1 , typename PointType2 , long d>
traits::value_type< PointType1 >
::type 
inner_prod_impl (PointType1 const &p1, PointType2 const &p2, cartesian_cs< d >, cartesian_cs< d >)
 Dispatched inner product function having full information about the coordinate systems. Vectors/Points are in a Cartesian coordinate system already, thus no transformation required.
template<typename PointType1 , typename PointType2 >
traits::value_type< PointType1 >
::type 
inner_prod (PointType1 const &p1, PointType2 const &p2)
 Returns the inner product of two vectors, which can be given in different coordinate systems.
template<typename SegmentType , typename KeyType >
void detect_interface_impl (SegmentType const &seg1, SegmentType const &seg2, KeyType const &key, no_handling_tag)
 A guard that forces a compile time error if no facets are available (i.e. disabled).
template<typename SegmentType , typename KeyType >
void detect_interface_impl (SegmentType const &seg1, SegmentType const &seg2, KeyType const &key, full_handling_tag)
 Implementation of interface facet detection with complexity O(N log(N)), where N is the number of facets in both segments.
template<typename SegmentType , typename KeyType >
void detect_interface (SegmentType const &seg1, SegmentType const &seg2, KeyType const &key)
 Public interface function for the detection of interface n-cells between two segments. No need to call this function explicitly, since it is called by is_interface().
template<typename ConfigType , typename ElementTag >
bool is_interface (element_t< ConfigType, ElementTag > const &el, segment_t< ConfigType > const &seg1, segment_t< ConfigType > const &seg2)
 Returns true if the n-cell is located at the interface between two segments.
template<typename NormTag , typename PointType , typename CSystem >
traits::value_type< PointType >
::type 
norm_impl (PointType const &p, CSystem const &)
 Dispatch for a point that needs coordinate conversion.
template<typename NormTag , typename PointType1 , long d>
traits::value_type< PointType1 >
::type 
norm_impl (PointType1 const &p, cartesian_cs< d >)
 Dispatch for a point that does not need coordinate conversion.
template<typename PointType , typename Tag >
traits::value_type< PointType >
::type 
norm (PointType const &p, Tag)
 Returns the norm of a point. The type of the norm is specified by a tag. Supported tags are one_tag, two_tag and inf_tag.
template<typename PointType >
traits::value_type< PointType >
::type 
norm (PointType const &p)
 Returns the 2-norm of a point. Result is such as if the point were transformed to Cartesian coordinates first.
template<typename PointType >
traits::value_type< PointType >
::type 
norm_1 (PointType const &p)
 Convenience shortcut for the 1-norm of a vector.
template<typename PointType >
traits::value_type< PointType >
::type 
norm_2 (PointType const &p)
 Convenience shortcut for the 2-norm of a vector.
template<typename PointType >
traits::value_type< PointType >
::type 
norm_inf (PointType const &p)
 Convenience shortcut for the inf-norm of a vector.
template<typename ConfigTypeIn , typename RefinementTag >
refinement_proxy< domain_t
< ConfigTypeIn >
, RefinementTag > 
refine (domain_t< ConfigTypeIn > const &domain_in, RefinementTag const &tag)
 Public interface for refinement of a domain. If local refinement is desired, cells or edges needs to be tagged using ViennaData with refinement_key.
template<typename ConfigTypeIn >
refinement_proxy< domain_t
< ConfigTypeIn >
, uniform_refinement_tag
refine_uniformly (domain_t< ConfigTypeIn > const &domain_in)
 Convenience overload for uniform refinement of a domain.
template<typename ConfigTypeIn >
refinement_proxy< domain_t
< ConfigTypeIn >
, local_refinement_tag
refine_locally (domain_t< ConfigTypeIn > const &domain_in)
 Convenience overload for adaptive refinement of a domain. Cells or edges needs to be tagged using ViennaData with refinement_key.
template<typename PointType1 , typename PointType2 , typename CSystem1 , typename CSystem2 >
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, CSystem1 const &, CSystem2 const &)
 Dispatch facility for two points with possibly different coordinate systems.
template<typename PointType1 , typename PointType2 , typename PointType3 , typename CSystem1 , typename CSystem2 , typename CSystem3 >
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3, CSystem1 const &, CSystem2 const &, CSystem3 const &)
 Dispatch facility for three points with possibly different coordinate systems.
template<typename PointType1 , typename PointType2 , typename PointType3 , typename PointType4 , typename CSystem1 , typename CSystem2 , typename CSystem3 , typename CSystem4 >
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3, PointType4 const &p4, CSystem1 const &, CSystem2 const &, CSystem3 const &, CSystem4 const &)
 Dispatch facility for four points with possibly different coordinate systems.
template<typename PointType1 , typename PointType2 , long d>
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, cartesian_cs< d >, cartesian_cs< d >)
 Dispatch facility for two points in Cartesian coordinates.
template<typename PointType1 , typename PointType2 , typename PointType3 , long d>
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3, cartesian_cs< d >, cartesian_cs< d >, cartesian_cs< d >)
 Dispatch facility for three points in Cartesian coordinates.
template<typename PointType1 , typename PointType2 , typename PointType3 , typename PointType4 , long d>
traits::value_type< PointType1 >
::type 
spanned_volume_impl (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3, PointType4 const &p4, cartesian_cs< d >, cartesian_cs< d >, cartesian_cs< d >, cartesian_cs< d >)
 Dispatch facility for four points in Cartesian coordinates.
template<typename PointType1 , typename PointType2 >
traits::value_type< PointType1 >
::type 
spanned_volume (PointType1 const &p1, PointType2 const &p2)
 Returns the volume of the 1-simplex (line) spanned by the two points.
template<typename PointType1 , typename PointType2 , typename PointType3 >
traits::value_type< PointType1 >
::type 
spanned_volume (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3)
 Returns the two-dimensional volume of the 2-simplex (triangle) spanned by the three points.
template<typename PointType1 , typename PointType2 , typename PointType3 , typename PointType4 >
traits::value_type< PointType1 >
::type 
spanned_volume (PointType1 const &p1, PointType2 const &p2, PointType3 const &p3, PointType4 const &p4)
 Returns the three-dimensional volume of the 3-simplex (tetrahedron) spanned by the four points.
template<typename ElementType >
ElementType::config_type::numeric_type surface (ElementType const &element)
 Returns the surface of a n-cell.
template<typename ConfigType >
ConfigType::numeric_type surface (domain_t< ConfigType > const &d)
 Returns the surface of a domain.
template<typename ConfigType >
ConfigType::numeric_type surface (segment_t< ConfigType > const &d)
 Returns the surface of a segment.
template<typename ElementType >
ElementType::config_type::numeric_type volume (ElementType const &cell)
 Returns the n-dimensional volume of a n-cell.
template<typename ConfigType >
ConfigType::numeric_type volume (domain_t< ConfigType > const &d)
 Returns the N-dimensional volume of a domain, where the cell type has topological dimension N.
template<typename ConfigType >
ConfigType::numeric_type volume (segment_t< ConfigType > const &d)
 Returns the N-dimensional volume of a segment, where the cell type has topological dimension N.
template<typename DomainType , typename InterfaceAreaKey , typename BoxVolumeKey >
void apply_voronoi (DomainType const &domain, InterfaceAreaKey const &interface_area_key=viennagrid::voronoi_interface_area_key(), BoxVolumeKey const &box_volume_key=viennagrid::voronoi_box_volume_key())
 Writes Voronoi information to the domain or segment using the provided keys.
template<typename DomainType >
void apply_voronoi (DomainType const &domain)
 Convenience overload for storing Voronoi information on a domain or segment. Uses the default keys for interface areas and box volumes.
template<long dim, typename DomainConfig >
ncell_range< domain_t
< DomainConfig >, dim > 
ncells (domain_t< DomainConfig > &d)
 Main function for range retrieval. Specialization for iteration over k-cells on the domain.
template<typename DomainConfig >
ncell_proxy< domain_t
< DomainConfig > > 
ncells (domain_t< DomainConfig > &d)
 Main function for range retrieval. Specialization for iteration over k-cells on the domain. Returns only a proxy that must be assigned to a range object.
template<long dim, typename DomainConfig >
const_ncell_range< domain_t
< DomainConfig >, dim > 
ncells (domain_t< DomainConfig > const &d)
 Main function for const range retrieval. Specialization for iteration over k-cells on the domain.
template<typename DomainConfig >
const_ncell_proxy< domain_t
< DomainConfig > > 
ncells (domain_t< DomainConfig > const &d)
 Main function for const range retrieval. Specialization for iteration over k-cells on the domain. Returns only a proxy that must be assigned to a range object.
template<long dim, typename Config , typename ElementTag >
result_of::ncell_range
< element_t< Config,
ElementTag >, dim >::type 
ncells (element_t< Config, ElementTag > &d)
 Main function for range retrieval. Specialization for iteration over k-cells of a n-cell.
template<typename Config , typename ElementTag >
ncell_proxy< element_t< Config,
ElementTag > > 
ncells (element_t< Config, ElementTag > &d)
 Main function for range retrieval. Specialization for iteration over k-cells of a n-cell. Returns only a proxy that must be assigned to a range object.
template<long dim, typename Config , typename ElementTag >
result_of::const_ncell_range
< element_t< Config,
ElementTag >, dim >::type 
ncells (element_t< Config, ElementTag > const &d)
 Main function for const range retrieval. Specialization for iteration over k-cells of a n-cell.
template<typename Config , typename ElementTag >
const_ncell_proxy< element_t
< Config, ElementTag > > 
ncells (element_t< Config, ElementTag > const &d)
 Main function for const range retrieval. Specialization for iteration over k-cells of a n-cell. Returns only a proxy that must be assigned to a range object.
template<long dim_start, long dim_iter, typename RangeType , typename KeyType , typename EnclosingType >
void init_coboundary (KeyType const &key, EnclosingType const &domain)
 A helper function that sets up the co-boundary information.
template<long dim, typename Config , typename ElementTag >
ncell_range< element_t< Config,
ElementTag >, dim, true > 
ncells (element_t< Config, ElementTag > &e, domain_t< Config > &d)
 Returns the co-boundary range of topological dimension k for a n-cell, k>n.
template<typename Config , typename ElementTag >
cobnd_proxy< element_t< Config,
ElementTag >, domain_t< Config > > 
ncells (element_t< Config, ElementTag > &e, domain_t< Config > &d)
 Returns a proxy object for the iteration over the neighbor elements within a domain. Non-const version.
template<long dim, typename Config , typename ElementTag >
ncell_range< element_t< Config,
ElementTag >, dim, true > 
ncells (element_t< Config, ElementTag > &e, segment_t< Config > &seg)
 Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.
template<typename Config , typename ElementTag >
cobnd_proxy< element_t< Config,
ElementTag >, segment_t
< Config > > 
ncells (element_t< Config, ElementTag > &e, segment_t< Config > &seg)
 Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.
template<long dim, typename Config , typename ElementTag >
const_ncell_range< element_t
< Config, ElementTag >, dim,
true > 
ncells (element_t< Config, ElementTag > const &e, domain_t< Config > const &d)
 Returns a proxy object for the iteration over the neighbor elements within a domain. Non-const version.
template<typename Config , typename ElementTag >
const_cobnd_proxy< element_t
< Config, ElementTag >
, domain_t< Config > > 
ncells (element_t< Config, ElementTag > const &e, domain_t< Config > const &d)
 Returns a proxy object for the iteration over the neighbor elements within a domain. Const version.
template<long dim, typename Config , typename ElementTag >
const_ncell_range< element_t
< Config, ElementTag >, dim,
true > 
ncells (element_t< Config, ElementTag > const &e, segment_t< Config > const &seg)
 Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.
template<typename Config , typename ElementTag >
const_cobnd_proxy< element_t
< Config, ElementTag >
, segment_t< Config > > 
ncells (element_t< Config, ElementTag > const &e, segment_t< Config > const &seg)
 Returns a proxy object for the iteration over the neighbor elements within a segment. Const version.
template<typename ConfigType , typename Tag1 , typename Tag2 >
result_of::ncell< ConfigType, 0 >
::type 
local_vertex (element_t< ConfigType, Tag1 > const &host_ncell, element_t< ConfigType, Tag2 > const &bnd_kcell, std::size_t index)
 Returns the index-th vertices of a boundary k-cell in the orientation induced by the hosting n-cell.
template<long dim, typename DomainConfig >
ncell_range< segment_t
< DomainConfig >, dim > 
ncells (segment_t< DomainConfig > &d)
 Main function for range retrieval. Specialization for iteration over n-cells of a segment.
template<typename DomainConfig >
ncell_proxy< segment_t
< DomainConfig > > 
ncells (segment_t< DomainConfig > &d)
 Main function for range retrieval. Specialization for iteration over n-cells of a segment. Returns only a proxy that must be assigned to a range object.
template<long dim, typename DomainConfig >
const_ncell_range< segment_t
< DomainConfig >, dim > 
ncells (segment_t< DomainConfig > const &d)
 Main function for range retrieval. Specialization for iteration over n-cells of a segment.
template<typename DomainConfig >
const_ncell_proxy< segment_t
< DomainConfig > > 
ncells (segment_t< DomainConfig > const &d)
 Main function for const-range retrieval. Specialization for iteration over n-cells of a segment. Returns only a proxy that must be assigned to a range object.
template<typename ConfigType >
domain_t< ConfigType >
::segment_container & 
segments (domain_t< ConfigType > &domain)
 Convenience function for accessing the segments of the domain. Equivalent to domain.segments().
template<typename ConfigType >
domain_t< ConfigType >
::segment_container const & 
segments (domain_t< ConfigType > const &domain)
 Convenience function for accessing the segments of the domain. Equivalent to domain.segments().
template<typename ConfigType , typename ElementTag >
std::ostream & operator<< (std::ostream &os, element_t< ConfigType, ElementTag > const &el)
 Overload for the output streaming operator.
template<typename ConfigType >
std::ostream & operator<< (std::ostream &os, element_t< ConfigType, point_tag > const &el)
 Overload for the output streaming operator for the vertex type.
template<typename PointType , typename CoordinateSystem >
result_of::cartesian_point
< PointType >::type 
to_cartesian_impl (PointType const &p, CoordinateSystem const &)
 Helper function for the conversion to Cartesian coordinates. Should not be called directly. Use to_cartesian() instead.
template<typename PointType >
result_of::cartesian_point
< PointType >::type 
to_cartesian (PointType const &p)
 Convenience function for converting a point to Cartesian coordinates.
template<typename PointType , long d>
PointType const & to_cartesian_impl (PointType const &p, cartesian_cs< d >)
 Helper function for the transformation of any point to Cartesian coordinates. Should not be called directly - use to_cartesian() instead.
template<typename PointType , long d>
PointType & to_cartesian_impl (PointType &p, cartesian_cs< d >)
 Helper function for the transformation of any point to Cartesian coordinates. Should not be called directly - use to_cartesian() instead.
template<typename CoordType , typename CoordinateSystem >
point_t< CoordType,
CoordinateSystem > 
operator* (double val, point_t< CoordType, CoordinateSystem > const &p)
 Overload for stretching a vector from the left.
template<typename CoordType , typename CoordinateSystem >
std::ostream & operator<< (std::ostream &os, point_t< CoordType, CoordinateSystem > const &p)
 Overload of the output stream operator. Allows simple printing to screen or streaming to file.
template<typename VertexType >
bool stable_line_is_longer (VertexType const *v1_1, VertexType const *v1_2, VertexType const *v2_1, VertexType const *v2_2)
 Compares the lines (v1_1, v1_2) and (v2_1, v2_2) and returns true if the first is longer.

Detailed Description

The main ViennaGrid namespace. Most functionality resides in this namespace.


Typedef Documentation

typedef std::size_t dim_type

A global size_type equivalent for use throughout ViennaData.

typedef hypercube_tag<3> hexahedron_tag

Convenience type definition for a hexahedron.

typedef simplex_tag<1> line_tag

Convenience type definition for a line.

typedef hypercube_tag<2> quadrilateral_tag

Convenience type definition for a quadrilateral.

typedef simplex_tag<3> tetrahedron_tag

Convenience type definition for a tetrahedron.

typedef simplex_tag<2> triangle_tag

Convenience type definition for a triangle.


Function Documentation

void viennagrid::apply_voronoi ( DomainType const &  domain,
InterfaceAreaKey const &  interface_area_key = viennagrid::voronoi_interface_area_key(),
BoxVolumeKey const &  box_volume_key = viennagrid::voronoi_box_volume_key() 
)

Writes Voronoi information to the domain or segment using the provided keys.

Parameters:
domain A ViennaGrid domain or segment
interface_area_key The ViennaData key used for storing the interface area on edges
box_volume_key The ViennaData key used for storing the box volumes on edges and vertices
void viennagrid::apply_voronoi ( DomainType const &  domain  ) 

Convenience overload for storing Voronoi information on a domain or segment. Uses the default keys for interface areas and box volumes.

viennagrid::result_of::point<typename CellType::config_type>::type viennagrid::centroid ( CellType const &  cell  ) 

The public interface function for the computation of a centroid.

Parameters:
cell The n-cell for which the centroid should be computed
viennagrid::result_of::point<ConfigType>::type viennagrid::centroid ( segment_t< ConfigType > const &  segment  ) 

The public interface function for the computation of the centroid of a segment.

Parameters:
segment The segment object
viennagrid::result_of::point<ConfigType>::type viennagrid::centroid ( domain_t< ConfigType > const &  domain  ) 

The public interface function for the computation of the centroid of a domain.

Parameters:
domain The domain object
viennagrid::result_of::point<typename CellType::config_type>::type viennagrid::circumcenter ( CellType const &  cell  ) 

The public interface function for the calculation of the circumcenter.

Parameters:
cell The n-cell for which the circumcenter should be computed
PointType1 viennagrid::cross_prod ( PointType1 const &  v1,
PointType2 const &  v2 
)

Returns the cross product of two vectors. If the vectors have one or two components only, the zero vector is returned.

Parameters:
v1 The first vector given in some coordinate system
v2 The second vector given in another coordinate system
PointType1 viennagrid::cross_prod_impl ( PointType1 const &  p1,
PointType2 const &  p2,
cartesian_cs< d >  ,
cartesian_cs< d >   
)

Dispatched cross product function having information about the coordinate systems. Points are already in Cartesian coordinates, thus forwarding to the worker function directly.

PointType1 viennagrid::cross_prod_impl ( PointType1 const &  p1,
PointType2 const &  p2,
CSystem1 const &  ,
CSystem2 const &   
)

Dispatched cross product function having information about the coordinate systems. Transforms to Cartesian coordinates and forwards to calculation.

void viennagrid::detect_boundary ( DomainSegmentType const &  segment,
KeyType const &  key 
)

Public interface functions for boundary detection. No need to call it explicitly, since it is called by is_boundary().

Template Parameters:
DomainSegmentType Either a segment or a domain type
KeyType Type of the key used with ViennaData.
Parameters:
segment Either a segment or a domain object
key The key object for ViennaData
void viennagrid::detect_boundary_impl ( DomainSegmentType const &  seg,
KeyType const &  key,
full_handling_tag   
)

Implementation of boundary detection. Should not be called by library users.

void viennagrid::detect_boundary_impl ( DomainSegmentType const &  seg,
KeyType const &  key,
no_handling_tag   
)

Implementation of boundary detection for the case no facets are available. Issues a hopefully useful compiler error.

void viennagrid::detect_interface ( SegmentType const &  seg1,
SegmentType const &  seg2,
KeyType const &  key 
)

Public interface function for the detection of interface n-cells between two segments. No need to call this function explicitly, since it is called by is_interface().

Parameters:
seg1 The first segment
seg2 The second segment
key The key object for ViennaData
void viennagrid::detect_interface_impl ( SegmentType const &  seg1,
SegmentType const &  seg2,
KeyType const &  key,
no_handling_tag   
)

A guard that forces a compile time error if no facets are available (i.e. disabled).

void viennagrid::detect_interface_impl ( SegmentType const &  seg1,
SegmentType const &  seg2,
KeyType const &  key,
full_handling_tag   
)

Implementation of interface facet detection with complexity O(N log(N)), where N is the number of facets in both segments.

Parameters:
seg1 The first segment
seg2 The second segment
key Key object for use with ViennaData.
void viennagrid::init_coboundary ( KeyType const &  key,
EnclosingType const &  domain 
)

A helper function that sets up the co-boundary information.

traits::value_type<PointType1>::type viennagrid::inner_prod ( PointType1 const &  p1,
PointType2 const &  p2 
)

Returns the inner product of two vectors, which can be given in different coordinate systems.

Parameters:
p1 First vector
p2 Second vector
traits::value_type<PointType1>::type viennagrid::inner_prod_impl ( PointType1 const &  p1,
PointType2 const &  p2,
CSystem1 const &  ,
CSystem2 const &   
)

Dispatched inner product function having full information about the coordinate systems. Transforms to Cartesian coordinates and forwards the calculation to the worker.

traits::value_type<PointType1>::type viennagrid::inner_prod_impl ( PointType1 const &  p1,
PointType2 const &  p2,
cartesian_cs< d >  ,
cartesian_cs< d >   
)

Dispatched inner product function having full information about the coordinate systems. Vectors/Points are in a Cartesian coordinate system already, thus no transformation required.

bool viennagrid::is_boundary ( element_t< ConfigType, ElementTag > const &  el,
domain_t< ConfigType > const &  domain 
)

Returns true if a n-cell is located on the boundary of the domain.

Parameters:
el The n-cell
domain The ViennaGrid domain
bool viennagrid::is_boundary ( element_t< ConfigType, ElementTag > const &  el,
segment_t< ConfigType > const &  segment 
)

Returns true if a n-cell is located on the boundary of a segment.

Parameters:
el The n-cell
segment A segment of a domain
bool viennagrid::is_interface ( element_t< ConfigType, ElementTag > const &  el,
segment_t< ConfigType > const &  seg1,
segment_t< ConfigType > const &  seg2 
)

Returns true if the n-cell is located at the interface between two segments.

Parameters:
el The n-cell under test
seg1 The first segment
seg2 The sevond segment
result_of::ncell<ConfigType, 0>::type viennagrid::local_vertex ( element_t< ConfigType, Tag1 > const &  host_ncell,
element_t< ConfigType, Tag2 > const &  bnd_kcell,
std::size_t  index 
)

Returns the index-th vertices of a boundary k-cell in the orientation induced by the hosting n-cell.

Parameters:
host_ncell The hosting n-cell
bnd_kcell The boundary k-cell
index Index for the i-th vertex
cobnd_proxy< element_t<Config, ElementTag>, segment_t<Config> > viennagrid::ncells ( element_t< Config, ElementTag > &  e,
segment_t< Config > &  seg 
)

Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
seg The segment in which the neighbors must be located
Returns:
A proxy object
const_ncell_range< segment_t<DomainConfig>, dim> viennagrid::ncells ( segment_t< DomainConfig > const &  d  ) 

Main function for range retrieval. Specialization for iteration over n-cells of a segment.

ncell_range< segment_t< DomainConfig >, dim > ncells ( segment_t< DomainConfig > &  d  ) 

Main function for range retrieval. Specialization for iteration over n-cells of a segment.

ncell_proxy< segment_t< DomainConfig > > ncells ( segment_t< DomainConfig > &  d  ) 

Main function for range retrieval. Specialization for iteration over n-cells of a segment. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(segment);

const_ncell_proxy< segment_t<DomainConfig> > viennagrid::ncells ( segment_t< DomainConfig > const &  d  ) 

Main function for const-range retrieval. Specialization for iteration over n-cells of a segment. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(segment);

ncell_range< domain_t< DomainConfig >, dim > ncells ( domain_t< DomainConfig > &  d  ) 

Main function for range retrieval. Specialization for iteration over k-cells on the domain.

ncell_proxy< domain_t< DomainConfig > > ncells ( domain_t< DomainConfig > &  d  ) 

Main function for range retrieval. Specialization for iteration over k-cells on the domain. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(domain);

const_ncell_range< domain_t<DomainConfig>, dim> viennagrid::ncells ( domain_t< DomainConfig > const &  d  ) 

Main function for const range retrieval. Specialization for iteration over k-cells on the domain.

const_ncell_proxy< domain_t<DomainConfig> > viennagrid::ncells ( domain_t< DomainConfig > const &  d  ) 

Main function for const range retrieval. Specialization for iteration over k-cells on the domain. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(domain);

result_of::ncell_range< element_t< Config, ElementTag >, dim >::type ncells ( element_t< Config, ElementTag > &  d  ) 

Main function for range retrieval. Specialization for iteration over k-cells of a n-cell.

ncell_proxy< element_t< Config, ElementTag > > ncells ( element_t< Config, ElementTag > &  d  ) 

Main function for range retrieval. Specialization for iteration over k-cells of a n-cell. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(facet);

result_of::const_ncell_range< element_t<Config, ElementTag>, dim>::type viennagrid::ncells ( element_t< Config, ElementTag > const &  d  ) 

Main function for const range retrieval. Specialization for iteration over k-cells of a n-cell.

const_ncell_proxy< element_t<Config, ElementTag> > viennagrid::ncells ( element_t< Config, ElementTag > const &  d  ) 

Main function for const range retrieval. Specialization for iteration over k-cells of a n-cell. Returns only a proxy that must be assigned to a range object.

Allows to omit the topological dimension if this is clear from the range type, e.g. VertexRange vertices = ncells(facet);

const_cobnd_proxy< element_t<Config, ElementTag>, segment_t<Config> > viennagrid::ncells ( element_t< Config, ElementTag > const &  e,
segment_t< Config > const &  seg 
)

Returns a proxy object for the iteration over the neighbor elements within a segment. Const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
seg The segment in which the neighbors must be located
Returns:
A proxy object
ncell_range< element_t<Config, ElementTag>, dim, true> viennagrid::ncells ( element_t< Config, ElementTag > &  e,
domain_t< Config > &  d 
)

Returns the co-boundary range of topological dimension k for a n-cell, k>n.

cobnd_proxy< element_t<Config, ElementTag>, domain_t<Config> > viennagrid::ncells ( element_t< Config, ElementTag > &  e,
domain_t< Config > &  d 
)

Returns a proxy object for the iteration over the neighbor elements within a domain. Non-const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, domain);

Parameters:
e The element over which neighbors to iterate
d The domain in which the neighbors must be located
Returns:
A proxy object
ncell_range< element_t<Config, ElementTag>, dim, true> viennagrid::ncells ( element_t< Config, ElementTag > &  e,
segment_t< Config > &  seg 
)

Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
seg The segment in which the neighbors must be located
Returns:
A proxy object
const_ncell_range< element_t<Config, ElementTag>, dim, true> viennagrid::ncells ( element_t< Config, ElementTag > const &  e,
domain_t< Config > const &  d 
)

Returns a proxy object for the iteration over the neighbor elements within a domain. Non-const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
d The domain in which the neighbors must be located
Returns:
A proxy object
const_cobnd_proxy< element_t<Config, ElementTag>, domain_t<Config> > viennagrid::ncells ( element_t< Config, ElementTag > const &  e,
domain_t< Config > const &  d 
)

Returns a proxy object for the iteration over the neighbor elements within a domain. Const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
d The domain in which the neighbors must be located
Returns:
A proxy object
const_ncell_range< element_t<Config, ElementTag>, dim, true> viennagrid::ncells ( element_t< Config, ElementTag > const &  e,
segment_t< Config > const &  seg 
)

Returns a proxy object for the iteration over the neighbor elements within a segment. Non-const version.

The typical use of this function is as shortcut for the initialization of a Range, e.g. EdgeOnVertexRange edges = ncells(vertex, segment);

Parameters:
e The element over which neighbors to iterate
seg The segment in which the neighbors must be located
Returns:
A proxy object
traits::value_type<PointType>::type viennagrid::norm ( PointType const &  p,
Tag   
)

Returns the norm of a point. The type of the norm is specified by a tag. Supported tags are one_tag, two_tag and inf_tag.

Parameters:
p The vector (point) for which the norm should be computed.
traits::value_type<PointType>::type viennagrid::norm ( PointType const &  p  ) 

Returns the 2-norm of a point. Result is such as if the point were transformed to Cartesian coordinates first.

traits::value_type<PointType>::type viennagrid::norm_1 ( PointType const &  p  ) 

Convenience shortcut for the 1-norm of a vector.

traits::value_type<PointType>::type viennagrid::norm_2 ( PointType const &  p  ) 

Convenience shortcut for the 2-norm of a vector.

traits::value_type<PointType>::type viennagrid::norm_impl ( PointType const &  p,
CSystem const &   
)

Dispatch for a point that needs coordinate conversion.

traits::value_type<PointType1>::type viennagrid::norm_impl ( PointType1 const &  p,
cartesian_cs< d >   
)

Dispatch for a point that does not need coordinate conversion.

traits::value_type<PointType>::type viennagrid::norm_inf ( PointType const &  p  ) 

Convenience shortcut for the inf-norm of a vector.

point_t<CoordType, CoordinateSystem> viennagrid::operator* ( double  val,
point_t< CoordType, CoordinateSystem > const &  p 
)

Overload for stretching a vector from the left.

std::ostream& viennagrid::operator<< ( std::ostream &  os,
element_t< ConfigType, ElementTag > const &  el 
)

Overload for the output streaming operator.

std::ostream& viennagrid::operator<< ( std::ostream &  os,
element_t< ConfigType, point_tag > const &  el 
)

Overload for the output streaming operator for the vertex type.

std::ostream& viennagrid::operator<< ( std::ostream &  os,
point_t< CoordType, CoordinateSystem > const &  p 
)

Overload of the output stream operator. Allows simple printing to screen or streaming to file.

refinement_proxy< domain_t<ConfigTypeIn>, RefinementTag > viennagrid::refine ( domain_t< ConfigTypeIn > const &  domain_in,
RefinementTag const &  tag 
)

Public interface for refinement of a domain. If local refinement is desired, cells or edges needs to be tagged using ViennaData with refinement_key.

refinement_proxy< domain_t<ConfigTypeIn>, local_refinement_tag > viennagrid::refine_locally ( domain_t< ConfigTypeIn > const &  domain_in  ) 

Convenience overload for adaptive refinement of a domain. Cells or edges needs to be tagged using ViennaData with refinement_key.

refinement_proxy< domain_t<ConfigTypeIn>, uniform_refinement_tag > viennagrid::refine_uniformly ( domain_t< ConfigTypeIn > const &  domain_in  ) 

Convenience overload for uniform refinement of a domain.

domain_t<ConfigType>::segment_container& viennagrid::segments ( domain_t< ConfigType > &  domain  ) 

Convenience function for accessing the segments of the domain. Equivalent to domain.segments().

domain_t<ConfigType>::segment_container const& viennagrid::segments ( domain_t< ConfigType > const &  domain  ) 

Convenience function for accessing the segments of the domain. Equivalent to domain.segments().

traits::value_type<PointType1>::type viennagrid::spanned_volume ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3,
PointType4 const &  p4 
)

Returns the three-dimensional volume of the 3-simplex (tetrahedron) spanned by the four points.

traits::value_type<PointType1>::type viennagrid::spanned_volume ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3 
)

Returns the two-dimensional volume of the 2-simplex (triangle) spanned by the three points.

traits::value_type<PointType1>::type viennagrid::spanned_volume ( PointType1 const &  p1,
PointType2 const &  p2 
)

Returns the volume of the 1-simplex (line) spanned by the two points.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
CSystem1 const &  ,
CSystem2 const &   
)

Dispatch facility for two points with possibly different coordinate systems.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3,
CSystem1 const &  ,
CSystem2 const &  ,
CSystem3 const &   
)

Dispatch facility for three points with possibly different coordinate systems.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3,
cartesian_cs< d >  ,
cartesian_cs< d >  ,
cartesian_cs< d >   
)

Dispatch facility for three points in Cartesian coordinates.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3,
PointType4 const &  p4,
cartesian_cs< d >  ,
cartesian_cs< d >  ,
cartesian_cs< d >  ,
cartesian_cs< d >   
)

Dispatch facility for four points in Cartesian coordinates.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
PointType3 const &  p3,
PointType4 const &  p4,
CSystem1 const &  ,
CSystem2 const &  ,
CSystem3 const &  ,
CSystem4 const &   
)

Dispatch facility for four points with possibly different coordinate systems.

traits::value_type<PointType1>::type viennagrid::spanned_volume_impl ( PointType1 const &  p1,
PointType2 const &  p2,
cartesian_cs< d >  ,
cartesian_cs< d >   
)

Dispatch facility for two points in Cartesian coordinates.

bool viennagrid::stable_line_is_longer ( VertexType const *  v1_1,
VertexType const *  v1_2,
VertexType const *  v2_1,
VertexType const *  v2_2 
)

Compares the lines (v1_1, v1_2) and (v2_1, v2_2) and returns true if the first is longer.

Ensures that the result is the same no matter in which order the parameters are passed. If the two lines have equal length, the line with the larger vertex IDs involved is considered as longer.

ElementType::config_type::numeric_type viennagrid::surface ( ElementType const &  element  ) 

Returns the surface of a n-cell.

ConfigType::numeric_type viennagrid::surface ( domain_t< ConfigType > const &  d  ) 

Returns the surface of a domain.

ConfigType::numeric_type viennagrid::surface ( segment_t< ConfigType > const &  d  ) 

Returns the surface of a segment.

result_of::cartesian_point<PointType>::type viennagrid::to_cartesian ( PointType const &  p  ) 

Convenience function for converting a point to Cartesian coordinates.

Template Parameters:
PointType A point type for which the traits::coordinate_system<> metafunction can deduce the coordinate system
result_of::cartesian_point<PointType>::type viennagrid::to_cartesian_impl ( PointType const &  p,
CoordinateSystem const &   
)

Helper function for the conversion to Cartesian coordinates. Should not be called directly. Use to_cartesian() instead.

PointType const& viennagrid::to_cartesian_impl ( PointType const &  p,
cartesian_cs< d >   
)

Helper function for the transformation of any point to Cartesian coordinates. Should not be called directly - use to_cartesian() instead.

PointType& viennagrid::to_cartesian_impl ( PointType &  p,
cartesian_cs< d >   
)

Helper function for the transformation of any point to Cartesian coordinates. Should not be called directly - use to_cartesian() instead.

ConfigType::numeric_type viennagrid::volume ( domain_t< ConfigType > const &  d  ) 

Returns the N-dimensional volume of a domain, where the cell type has topological dimension N.

ConfigType::numeric_type viennagrid::volume ( segment_t< ConfigType > const &  d  ) 

Returns the N-dimensional volume of a segment, where the cell type has topological dimension N.

ElementType::config_type::numeric_type viennagrid::volume ( ElementType const &  cell  ) 

Returns the n-dimensional volume of a n-cell.