Data Structures

Here are the data structures with brief descriptions:
assert_bracket_operator_access< ContainerType >A guard that ensures that operator[] access is possible. Throws a verbose compile time error if access is not possible
assert_bracket_operator_access< std::deque< ElementType > >Specialization: Allow operator[] if the underlying container is a std::deque<>
assert_bracket_operator_access< std::vector< ElementType > >Specialization: Allow operator[] if the underlying container is a std::vector<>
bad_file_format_exceptionProvides an exception for the case a parser problem occurs
bndcell_filler< ElementTag, k >Worker class that sets up the boundary k-cells of a n-cell
bndcell_filler< hexahedron_tag, 1 >Fills a segment or a domain with the edges of a hexahedron
bndcell_filler< hexahedron_tag, 2 >Fills a segment or a domain with the facets of a hexahedron
bndcell_filler< quadrilateral_tag, 1 >Fills a segment or a domain with the edges/facets of a quadrilateral
bndcell_filler< tetrahedron_tag, 1 >Fills a segment or a domain with the edges of a tetrahedron
bndcell_filler< tetrahedron_tag, 2 >Fills a segment or a domain with the edges/facets of a tetrahedron
bndcell_filler< triangle_tag, 1 >Fills a segment or a domain with the edges of a triangle
bndcell_handling< ConfigType, T, dim >Metafunction for the storage of boundary k-cells of an n-cell. By default, pointers to boundary k-cells are stored on n-cells
bndcell_handling< ConfigType, domain_t< ConfigType >, 0 >Specialization of the k-cell handling for the domain. Vertices always uses full handling (it is the defining entity of an element)
bndcell_handling< ConfigType, domain_t< ConfigType >, dim >Specialization of the k-cell handling for the domain
bndcell_handling< ConfigType, segment_t< ConfigType >, 0 >Specialization of the k-cell handling for segments. Vertices always uses full handling (it is the defining entity of an element)
bndcell_handling< ConfigType, segment_t< ConfigType >, dim >Specialization of the k-cell handling for segments
bndcell_handling< ConfigType, T, 0 >Specialization of the boundary k-cell handling for vertices. Vertex level always uses full handling (it is the defining entity of an element)
bndcell_orientation< ConfigType, T, dim >Metafunction for local-to-global-orienters: By default, orienters are stored on n-cells
bndcells< ElementTag, level >Holds the topological information about boundary cells for a n-cell
bndcells< hexahedron_tag, 0 >Topological description of the boundary 0-cells of a hexahedron
bndcells< hexahedron_tag, 1 >Topological description of the boundary 1-cells of a hexahedron
bndcells< hexahedron_tag, 2 >Topological description of the boundary 2-cells of a hexahedron
bndcells< hypercube_tag< 1 >, 0 >Topological description of the 0-cells of a line
bndcells< quadrilateral_tag, 0 >Topological description of the boundary 0-cells of a quadrilateral
bndcells< quadrilateral_tag, 1 >Topological description of the boundary 1-cells of a quadrilateral
bndcells< simplex_tag< 1 >, 0 >Topological description of the 0-cells of a line
bndcells< tetrahedron_tag, 0 >Topological description of the boundary 0-cells of a tetrahedron
bndcells< tetrahedron_tag, 1 >Topological description of the boundary 1-cells of a tetrahedron
bndcells< tetrahedron_tag, 2 >Topological description of the boundary 2-cells of a tetrahedron
bndcells< triangle_tag, 0 >Topological description of the boundary 0-cells (vertices) of a triangle
bndcells< triangle_tag, 1 >Topological description of the boundary 1-cells (edges) of a triangle
boundary_key< T >A key type for storing boundary information on n-cells, segments and domains
boundary_key< domain_t< ConfigType > >Specialization for domains
boundary_key< element_t< ConfigType, ElementTag > >Specialization for n-cells
boundary_key< segment_t< ConfigType > >Specialization for segments
boundary_ncell_layer< ConfigType, ElementTag, dim, handling_tag, orienter_tag, LevelNull >A class holding all information about boundary k-cells of a n-cell
boundary_ncell_layer< ConfigType, ElementTag, 0, handling_tag, orienter_tag, true >Specialization for the vertex level. Recursion ends here
boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, full_handling_tag, false >Implementation of full storage of k-cells including orientations
boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, no_handling_tag, false >Implementation of boundary k-cell storage without orientation
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
boundary_setter< dim >Helper struct for setting boundary flag of lower level elements of a facet
boundary_setter< -1 >Ends the recursion below the vertex level
cannot_open_file_exceptionProvides an exception for the case a file cannot be opened
cartesian_cs< d >Provides the basic operations in a cartesian coordinate system
cartesian_point< PointType >Convenience metafunction for the conversion to Cartesian coordinates
char_to_lower< dummy >Functor for conversion to lowercase (avoids tolower())
cobnd_proxy< T, U >A proxy object for cheaper setup of range objects using the ncells<>() function
coboundary_key< T, dim >A key used for ViennaData to store coboundary information on n-cells
config< T >Metafunction returning the configuration class of a topological element
config< domain_t< ConfigType > >Metafunction returning the configuration class of a topological element. Specialization for a domain
config< element_t< ConfigType, ElementTag > >Metafunction returning the configuration class of a topological element. Specialization for a n-cell
config< segment_t< ConfigType > >Metafunction returning the configuration class of a topological element. Specialization for a segment
const_cobnd_proxy< T, U >A proxy object for cheaper setup of range objects using the ncells<>() function
const_ncell_proxy< T >A proxy class for retrieving const n-cell ranges
const_ncell_range< T, dim >Meta function for returning a const-range of n-cells
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
const_ncell_range< element_t< Config, ElementTag >, dim >Const Range type retrieval for boundary and coboundary iteration
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
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
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
const_on_element_iterator< ElementType >Iterator class for const iteration over a range of elements given by a container of pointers
const_on_segment_iterator< IteratorType, ElementType >Iterator for const iteration over n-cells of a segment
coordinate_converter< FromPointType, ToPointType, FromCoordinateSystem, ToCoordinateSystem >A conversion facility for transformations between coordinate systems
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 2 >, polar_cs >A functor for the transformation from two-dimensional Cartesian coordinates to polar coodinates
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, cylindrical_cs >A functor for the transformation from three-dimensional Cartesian coordinates to cylindrical coodinates
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, spherical_cs >A functor for the transformation from three-dimensional Cartesian coordinates to spherical coodinates
coordinate_converter< FromPointType, ToPointType, cylindrical_cs, cartesian_cs< 3 > >A functor for the transformation from cylindrical coodinates to three-dimensional Cartesian coordinates
coordinate_converter< FromPointType, ToPointType, cylindrical_cs, spherical_cs >A functor for the transformation from cylindrical coordinates to spherical coodinates
coordinate_converter< FromPointType, ToPointType, polar_cs, cartesian_cs< 2 > >A functor for the transformation from polar coordinates to two-dimensional Cartesian coordinates
coordinate_converter< FromPointType, ToPointType, spherical_cs, cartesian_cs< 3 > >A functor for the transformation from spherical coodinates to three-dimensional Cartesian coordinates
coordinate_converter< FromPointType, ToPointType, spherical_cs, cylindrical_cs >A functor for the transformation from spherical coodinates to cylindrical coordinates
coordinate_system< PointType >Returns the coordinate system of a point. Must be specialized for a user-provided point type
coordinate_system< point_t< CoordType, CoordinateSystem > >Returns the coordinate system of a point. Specialization for a ViennaGrid point
cross_prod_impl< PointType, 1 >Implementation of the cross product calculation in 1d for compatibility. Returns the zero-vector
cross_prod_impl< PointType, 2 >Implementation of the cross product calculation in 2d for compatibility. Returns the zero-vector
cross_prod_impl< PointType, 3 >Implementation of the cross product calculation in 3d
cs_base< CSystem >Common base for all non-cartesian coordinate systems
cylindrical_csProvides the basic operations in a cylindrical coordinate system (rho, theta, z)
data_accessor_interface< ElementType >The interface for all data accessor wrappers. Uses type erasure to wrap the templated wrappers into a single container
data_accessor_wrapper< ElementType >The final wrapper class for IO implementations. Provides a uniform type for all quantity types on a n-cell
dimension< point_t< CoordType, CoordinateSystem > >Returns the geometric dimension of a point. Specialization for a ViennaGrid point
dimension_tag< d >A helper tag for dispatches based on the geometrical or topological dimension
domain< ConfigType >Metafunction for returning the domain type for a given configuration class
domain_iterators< Config, dim, cell_level >Helper for iterator construction for iteration over the whole domain
domain_iterators< Config, 0, cell_level >Helper for iterator construction for vertex iteration over the whole domain
domain_iterators< Config, cell_level, cell_level >Helper for iterator construction for cell iteration over the whole domain
domain_layers< Config, dim, is_cell, STOR >Class holding all n-cells of a particular topological dimension n. Uses recursive inheritance similar to n-cells themselves
domain_layers< Config, 0, is_cell, STOR >Specialization for the vertex level. Terminates the recursive inheritance
domain_layers< Config, dim, false, no_handling_tag >Specialization of a domin layer without the storage of n-cells
domain_layers< Config, dim, true, full_handling_tag >Specialization for the cell level
domain_segment_container< DomainType, SegmentType >Class responsible for holding the segments inside a domain
domain_subcell_iterator< ElementType, MapIterator >Iterator over non-vertices and non-cells on a domain
domain_t< Config >The domain class. Assembled at compile time by recursive inheritance for each topological level by the detail::domain_layers class
DXHelper< DIM >A helper class returning dimension-dependent attribute strings
DXHelper< 1 >
DXHelper< 2 >
DXHelper< 3 >
element_container< domain_t< ConfigType >, 0, cell_level >Metafunction returning the container used for storing the n-cells in the domain. Specialization for a vertices
element_container< domain_t< ConfigType >, cell_level, cell_level >Metafunction returning the container used for storing the n-cells in the domain. Specialization for a cells
element_container< domain_t< ConfigType >, dim, cell_level >Metafunction returning the container used for storing the n-cells in the domain
element_container< element_t< Config, ElementTag >, dim, cell_level >Returns the internal storage type of ranges for boundary k-cells
element_container< segment_t< config_type >, 0, cell_level >Metafunction returning the internal storage scheme of a segment at vertex level
element_container< segment_t< config_type >, cell_level, cell_level >Metafunction returning the internal storage scheme of a segment at cell level
element_container< segment_t< config_type >, dim, cell_level >Metafunction returning the internal storage scheme of a segment at non-vertex and non-cell level
element_id_handler< ConfigType, ElementTag >Metafunction that returns the ID handling class of an n-cell
element_key< ConfigType, ElementType >A key type that uniquely identifies an element by its vertices
element_orientation< num_vertices >A permutator for mapping local orientations to global vertices of a boundary k-cell
element_refinement< tetrahedron_tag >Class specialization for the refinement of a tetrahedron: A LOT of spaghetti-code to follow
element_refinement< triangle_tag >Specialization of the refinement class for a triangle
element_t< ConfigType, ElementTag >The main n-cell class. Assembled by recursive inheritance
element_t< ConfigType, point_tag >Specialization of the main n-cell class for vertices. Does not need to do any recursive inheritance here
ELEMENT_TAG_TO_VTK_TYPE< ElementTag >Translates element tags to VTK type identifiers
ELEMENT_TAG_TO_VTK_TYPE< hexahedron_tag >Specialization for a hexahedron
ELEMENT_TAG_TO_VTK_TYPE< hypercube_tag< 1 > >Specialization for a line (one-dimensional hypercube)
ELEMENT_TAG_TO_VTK_TYPE< quadrilateral_tag >Specialization for a quadrilateral
ELEMENT_TAG_TO_VTK_TYPE< simplex_tag< 1 > >Specialization for a line (one-dimensional simplex)
ELEMENT_TAG_TO_VTK_TYPE< tetrahedron_tag >Specialization for a tetrahedron
ELEMENT_TAG_TO_VTK_TYPE< triangle_tag >Specialization for a triangle
ElementIteratorChecker< ElementTag, level, handling_tag >A helper class that checks whether a certain iterator is available
ElementIteratorChecker< ElementTag, level, full_handling_tag >Specialization for an available iterator
ElementKeyStorageType< ConfigType, ElementType, IDHandler >Internal helper class: holds an ordered number of vertices. Comparisons also take permutations into account
ElementKeyStorageType< ConfigType, ElementType, integral_id >
full_handling_tagA tag denoting full storage of (boundary) k-cells of a certain topological dimension
global_scalar_data_accessor< ElementType, KeyType, DataType >Wrapper: Access scalar-valued data for all elements in the domain
global_vector_data_accessor< ElementType, KeyType, DataType >Wrapper: Access vector-valued data for all elements in the domain
hexahedral_3dPredefined configuration class for three-dimensional hypercube cells (hexahedra) in a 3d geometry using Cartesian coordinates
hypercube_tag< 1 >Topological description of a 1-cell (line). Same as simplex_tag<1>
hypercube_tag< 2 >Topological description of a quadrilateral
hypercube_tag< 3 >A hypercube of dimension 3, aka. hexahedron
id_ptr_compareHelper class for comparing the ID of n-cells, for which only the pointers are available. Used as comparison in std::map
inf_tagTag for denoting the infinity-norm
inner_prod_impl< PointType, 1 >Implementation of the inner product in one dimension
inner_prod_impl< PointType, 2 >Implementation of the inner product in two dimensions
inner_prod_impl< PointType, 3 >Implementation of the inner product in three dimensions
integral_idID handler class for IDs of type long. Has to be used for dense quantity storage with ViennaData
interface_keyA key used for ViennaData in order to store interface information
interface_setter< dim >Helper struct for setting interface flag of boundary k-cells of a facet
interface_setter< -1 >Specialization that stops recursion below the vertex level
is_smaller< a, b >Helper function for less-than comparison at compile time
iterator< element_t< config_type, tag >, dim >Returns the iterator for iteration over a range
iterator< viennagrid::const_ncell_range< T, dim, is_coboundary >, 0 >Specialization of the iterator metafunction for returning the correct iterator from a const range
iterator< viennagrid::ncell_range< T, dim, is_coboundary >, 0 >Specialization of the iterator metafunction for returning the correct iterator from a range
IteratorChecker< ElementType, level >Class that checks the validity of the requested iterator
IteratorChecker< element_t< Config, ElementTag >, level >Class that checks the validity of the requested iterator
key_dispatch< viennagrid::boundary_key< viennagrid::domain_t< ConfigType > > >
line_1dPredefined configuration class for one-dimensional simplex cells (lines) in a 1d geometry using Cartesian coordinates
line_2dPredefined configuration class for one-dimensional simplex cells (lines) in a 2d geometry using Cartesian coordinates
line_3dPredefined configuration class for one-dimensional simplex cells (lines) in a 3d geometry using Cartesian coordinates
local_refinement_tagA tag denoting local refinement
ncell< Config, dim, cell_level >Metafunction for the type retrieval of n-cells
ncell< Config, cell_level, cell_level >Metafunction for the type retrieval of n-cells. Specialization for the cells
ncell_proxy< T >A proxy class for retrieving n-cell ranges
ncell_range< T, dim >Meta function for returning a range of n-cells
ncell_range< domain_t< config_type >, dim, false >Main range class. Specialization for use with iteration or access to k-cells on the domain
ncell_range< element_t< Config, ElementTag >, dim >Range type retrieval for boundary and coboundary iteration
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
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
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
netgen_readerReader for Netgen files obtained from the 'Export mesh...' menu item. Tested with Netgen version 4.9.12
next_segment_layer_selector< Config, dim, handling_tag >Helper class that returns the next class type for recursive inheritance. Was introduced due to Visual Studio compilation problems of the first approach
next_segment_layer_selector< Config, 0, handling_tag >
next_segment_layer_selector< Config, dim, no_handling_tag >
no_handling_tagA tag denoting that the (boundary) k-cells should not be stored
norm_impl< Tag >
norm_impl< viennagrid::inf_tag >Implementation of the inf-norm
norm_impl< viennagrid::one_tag >Implementation of the 1-norm
norm_impl< viennagrid::two_tag >Implementation of the 2-norm
on_element_iterator< ElementType >Iterator class for iterating over a range of elements given by a container of pointers
on_segment_iterator< IteratorType, ElementType >Iterator for non-const iteration over n-cells of a segment
one_tagTag for denoting the 1-norm
opendx_writer< DomainType >The OpenDX writer object. Does not support segments - always the full domain is written
point< Config >Metafunction returning the type of a geometric point as used by vertices of the domain
point_filler< CoordType, d >A helper class for filling point coordinates with values
point_filler< CoordType, 1 >A helper class for filling point coordinates with values. Specialization for one dimension
point_filler< CoordType, 2 >A helper class for filling point coordinates with values. Specialization for two dimensions
point_filler< CoordType, 3 >A helper class for filling point coordinates with values. Specialization for three dimensions
point_index_out_of_bounds_exceptionAn exception class for invalid point indices
point_lessThis 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
point_t< CoordType, CoordinateSystem >Represents an arbitrary point in the underlying coordinate system
point_tagTopological description of a 0-cell (vertex)
pointer_idID handler class for IDs based on the n-cell address
PointWriter< dim >Helper class for writing points to file. Aids as a generic layer for point types that don't have operator<< overloaded in a suitable way
PointWriter< 1 >
PointWriter< 2 >
PointWriter< 3 >
polar_csProvides the basic operations in a polar coordinate system (r, phi)
quadrilateral_2dPredefined configuration class for two-dimensional hypercube cells (quadrilaterals) in a 2d geometry using Cartesian coordinates
quadrilateral_3dPredefined configuration class for two-dimensional hypercube cells (quadrilaterals) in a 3d geometry using Cartesian coordinates
refinement_keyA key type used for tagging edges for refinement using ViennaData
refinement_proxy< DomainType, RefinementTag >A proxy class that is used to allow ' refined_domain = refine(domain); ' without temporary
refinement_vertex_id_requirement< DomainType, VertexIDHandler >Refinement requies vertex IDs. This class makes sure that they are available
refinement_vertex_id_requirement< DomainType, pointer_id >
seg_cell_normal_dataData type for cell normals in algorithm/cell_normals.hpp (to be added in afuture release)
seg_cell_normal_tagTypes for cell normals in algorithm/cell_normals.hpp (to be added in afuture release)
segment< ConfigType >Metafunction for returning the type of a segment derived from the configuration class
segment_domain_holder< Conf >Class that holds a reference to the domain the segment belongs to
segment_iterators< Config, cell_level, cell_level >Segment iterator type retrieval for cells
segment_layers_empty< Config, dim >No handling of elements by cells on that level. Therefore, don't handle it within segments as well. Uses recursive inheritance
segment_layers_full< Config, dim >Full handling of a particular topological dimension of a segment
segment_layers_full< Config, 0 >Specialization of full handling at vertex level. Terminates recursion
segment_layers_top< Config, dim >Handler for cells in a segment. Since cells are the defining entity of segments, this requires special treatment
segment_mapping_key< SegmentType >
segment_scalar_data_accessor< ElementType, KeyType, DataType >Wrapper: Access scalar-valued data for elements per segment
segment_t< Conf >
segment_vector_data_accessor< ElementType, KeyType, DataType >Wrapper: Access vector-valued data for elements per segment
simplex_tag< 1 >Topological description of a 1-cell (line). Same as hypercube_tag<1>
simplex_tag< 2 >Topological description of a triangle
simplex_tag< 3 >Topological description of a tetrahedron
spanned_volume_impl< PointType, 1 >Implementation of the volume spanned by two points in one dimension
spanned_volume_impl< PointType, 2 >Implementation of the volume of simplices spanned by points in two geometrical dimension
spanned_volume_impl< PointType, 3 >Implementation of the volume of simplices spanned by points in three geometrical dimension
spherical_csProvides the basic operations in a spherical coordinate system (r, theta, phi) with theta denoting the elevation angle
static_size< point_t< CoordType, CoordinateSystem > >Returns the static (compile time) size of a point. Specialization for a ViennaGrid point
strCheckerChecks for a string being a number
tetrahedral_3dPredefined configuration class for three-dimensional simplex cells (tetrahedra) in a 3d geometry using Cartesian coordinates
triangular_2dPredefined configuration class for two-dimensional simplex cells (triangles) in a 2d geometry using Cartesian coordinates
triangular_3dPredefined configuration class for two-dimensional simplex cells (triangles) in a 3d geometry using Cartesian coordinates
two_tagTag for denoting the 2-norm
uniform_refinement_tagA tag denoting uniform refinement
value_type< point_t< CoordType, CoordinateSystem > >Value Type retrieval for a point. Returns the numeric type of each coordinate entry. Specialization for a ViennaGrid point
viennagrid_to_vtk_orientations< CellTag >Tranformations of reference orientations from ViennaGrid to VTK
viennagrid_to_vtk_orientations< hexahedron_tag >Specialization for hexahedra: Switch vertices (2, 3) and (6, 7)
viennagrid_to_vtk_orientations< quadrilateral_tag >Specialization for quadrilaterals: Switch vertices 2 and 3
voronoi_box_volume_keyViennaData key for the Voronoi box volume associated with an edge or vertex
voronoi_interface_area_keyViennaData key for the Voronoi interface area associated with an edge
vtk_reader< DomainType >A VTK reader class that allows to read meshes from XML-based VTK files as defined in http://www.vtk.org/pdf/file-formats.pdf
vtk_to_viennagrid_orientations< CellTag >Tranformations of reference orientations from VTK to ViennaGrid
vtk_to_viennagrid_orientations< hexahedron_tag >Specialization for hexahedra: Switch vertices (2, 3) and (6, 7)
vtk_to_viennagrid_orientations< quadrilateral_tag >Specialization for quadrilaterals: Switch vertices 2 and 3
vtk_vertex_id_repository< DomainSegmentType, IDHandler >A utility class managing the vertex ID in the domain. This is trivial if the vertices provide an ID, but a little tricky if vertex objects don't provide integral IDs
vtk_vertex_id_repository< viennagrid::domain_t< ConfigType >, viennagrid::integral_id >Specialization for a domain. The simple case: Vertices know their global IDs
vtk_vertex_id_repository< viennagrid::domain_t< ConfigType >, viennagrid::pointer_id >Specialization for a domain. The tough case: Vertices don't know their global IDs. Set up a map first
vtk_writer< DomainType >Main VTK writer class. Writes a domain or a segment to a file
xml_tag< dummy >Helper class that parses a XML tag