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. |
The main ViennaGrid namespace. Most functionality resides in this namespace.
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.
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.
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.
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.
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.
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.
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.
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().
DomainSegmentType | Either a segment or a domain type | |
KeyType | Type of the key used with ViennaData. |
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().
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.
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.
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.
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.
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.
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.
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);
e | The element over which neighbors to iterate | |
seg | The segment in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
seg | The segment in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
d | The domain in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
seg | The segment in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
d | The domain in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
d | The domain in which the neighbors must be located |
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);
e | The element over which neighbors to iterate | |
seg | The segment in which the neighbors must be located |
traits::value_type<PointType>::type viennagrid::norm | ( | PointType const & | p, | |
Tag | ||||
) |
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.
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.