| accessor_container< ElementT, ValueT, ContainerTagT > | Returns the underlying container type for storing data of type 'ValueT' on elements of type 'ElementT' |
| add_functor< SegmentT > | For internal use only |
| affine_transform_functor< MeshT > | Affine transform functor using a ScalarType * as matrix (row major layout) and a translation vector |
| appendix_accessor< value_type_, element_type > | Accessor class for the data members appended (injected) to an element |
| ascending_topological_order< T, U, correct_order > | |
| ascending_topological_order< T, U, false > | |
| at< typelist, index > | |
| at< typelist< head, tail >, 0 > | |
| at< typelist< head, tail >, i > | |
| bad_file_format_exception | Provides an exception for the case a parser problem occurs |
| bad_serialization_state_exception | Provides an exception for the bad serialization state |
| base_container_ | |
| base_dynamic_accessor< ValueType, AccessType > | Base class for all dynamic accessor |
| base_dynamic_field< ValueType, AccessType > | Common base class for dynamic data accessors fulfilling the field concept |
| base_id_unpack | |
| bnd_helper | |
| bnd_reader | Reader for .bnd files |
| boundary_cell_container_tag< viennagrid::dynamic_layout_tag, num > | |
| boundary_cell_container_tag< viennagrid::static_layout_tag, num > | |
| boundary_element_generator< ElementTag, BoundaryElementTag, BoundaryElementType > | Worker class that generates the boundary elements of a host element |
| boundary_element_generator< ElementTag, vertex_tag, BoundaryElementType > | |
| boundary_element_generator< hypercube_tag< 2 >, simplex_tag< 1 >, BoundaryElementType > | |
| boundary_element_generator< hypercube_tag< 3 >, hypercube_tag< 2 >, BoundaryElementType > | |
| boundary_element_generator< hypercube_tag< 3 >, simplex_tag< 1 >, BoundaryElementType > | |
| boundary_element_generator< plc_tag, line_tag, BoundaryElementType > | |
| boundary_element_generator< plc_tag, simplex_tag< 0 >, BoundaryElementType > | |
| boundary_element_generator< polygon_tag, simplex_tag< 1 >, BoundaryElementType > | |
| boundary_element_generator< simplex_tag< 1 >, simplex_tag< 0 >, BoundaryElementType > | Topological description of the 0-cells of a line |
| boundary_element_generator< simplex_tag< n >, simplex_tag< 1 >, BoundaryElementType > | |
| boundary_element_generator< simplex_tag< n >, simplex_tag< 2 >, BoundaryElementType > | |
| boundary_element_taglist< bnd_cell_typelist > | Metafunction for returning the list of boundary element tags for a certain element |
| boundary_elements< ElementTag, BoundaryElementTag > | Helper class for defining boundary element information |
| boundary_elements< hypercube_tag< 2 >, simplex_tag< 0 > > | Topological description of the 0-cells (vertices) of a quadrilateral |
| boundary_elements< hypercube_tag< 2 >, simplex_tag< 1 > > | Topological description of the 1-cells (edges/lines) of a quadrilateral |
| boundary_elements< hypercube_tag< 3 >, hypercube_tag< 2 > > | Topological description of the 2-cells (quadrilateral faces) of a hexahedron |
| boundary_elements< hypercube_tag< 3 >, simplex_tag< 0 > > | Topological description of the 0-cells (vertices) of a hexahedron |
| boundary_elements< hypercube_tag< 3 >, simplex_tag< 1 > > | Topological description of the 1-cells (edges/lines) of a hexahedron |
| boundary_elements< plc_tag, line_tag > | Topological description of the 1-cells (edges/lines) of a polygon |
| boundary_elements< plc_tag, vertex_tag > | Topological description of the 0-cells of a polygon |
| boundary_elements< polygon_tag, line_tag > | Topological description of the 1-cells (edges/lines) of a polygon |
| boundary_elements< polygon_tag, vertex_tag > | Topological description of the 0-cells of a polygon |
| boundary_elements< simplex_tag< n >, simplex_tag< k > > | Topological description of the boundary k-cells an n-simplex |
| boundary_information_collection_tag | A tag for identifying boundary information |
| boundary_information_collection_typemap< WrappedConfigType > | Creates the typemap for the boundary container collection for all elements using boundary_information_collection_typemap_impl with all elements within a wrapped domain except the cell |
| boundary_information_collection_typemap_impl< WrappedConfigType, ElementTaglistT > | Creates the typemap for the boundary container collection for all element within a element typelist |
| boundary_information_wrapper< container_type_, change_counter_type > | For internal use only |
| boundary_quantity_transfer_tag | Indicates a transfer from higher to lower topological dimension (boundary operation) |
| boundary_setter_functor< MeshT > | For internal use only |
| cannot_open_file_exception | Provides 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 |
| cell< something > | Metafunction for obtaining the cell type of something. Will fail if there is more than one cell type |
| cell_handle< SomethingT > | Convenience metafunction for the type retrieval of a cell handle. Will fail if there is more than one cell type |
| cell_id< SomethingT > | Convenience metafunction for the type retrieval of a cell ID. Will fail if there is more than one cell type |
| cell_only_segmentation< MeshT, ViewT, SegmentIDType, AppendixType, view_container_tag > | Metafunction for obtaining a segmentation type using only cells for a mesh type and with settings. Segment element information is not present (see segment_element_info for more information) |
| cell_range< SomethingT > | Convenience metafunction for the type retrieval of a cell range. Will fail if there is more than one cell type |
| cell_tag< something > | Metafunction for obtaining the cell tag of something. Will fail if there is more than one cell type |
| cell_tag_from_typelist< ElementTypelistT > | Meta function for determining the cell tag (tag of element with maximum topologic dimension) of a typelist of elements of element tags. The first cell tag is used |
| cells< something > | Metafunction for obtaining an element typelist of all cell types of something |
| char_to_lower< dummy > | Functor for conversion to lowercase (avoids the tolower() function as this can be a bit messy due to locales) |
| clear_all_functor< container_collection_type > | |
| coboundary_collection_tag | A tag for identifying the coboundary collection |
| coboundary_container_collection_typemap< WrappedConfigType, ElementTaglistT > | Creates the typemap for the coboundary container collection for all elements by merging all typemaps created by coboundary_container_collection_per_element_typemap |
| coboundary_container_wrapper< container_type_, change_counter_type > | For internal use only |
| coboundary_quantity_transfer_tag | Indicates a transfer from lower to higher topological dimension (coboundary operation) |
| coboundary_range< MeshOrSegmentHandleT, ElementTypeOrTagT, CoboundaryTypeOrTagT > | Metafunction for obtaining a coboundary range of an element type within a mesh/segment |
| coboundary_range_wrapper< ElementTypeOrTagT, CoboundaryTypeOrTagT, ContainerT > | |
| coboundary_range_wrapper< ElementTypeOrTagT, CoboundaryTypeOrTagT, const ContainerT > | |
| collection< typemap_ > | A collection is a compile-time map which returns objects of (possibly distinct) type based on the provided key type |
| collection_layer< viennagrid::null_type > | |
| collection_layer< viennagrid::typelist< viennagrid::static_pair< key_, value_ >, tail > > | |
| consistency< typemap > | |
| consistency< null_type > | |
| consistency< typelist< static_pair< key, value >, tail > > | |
| const_cell_handle< SomethingT > | Convenience metafunction for the type retrieval of a const cell handle. Will fail if there is more than one cell type |
| const_cell_range< SomethingT > | Convenience metafunction for the type retrieval of a const cell range. Will fail if there is more than one cell type |
| const_coboundary_range< MeshOrSegmentHandleT, ElementTypeOrTagT, CoboundaryTypeOrTagT > | Metafunction for obtaining a const coboundary range of an element type within a mesh/segment |
| const_edge_handle< SomethingT > | Convenience metafunction for the type retrieval of a const line handle (same as const_line_handle) |
| const_edge_range< SomethingT > | Convenience metafunction for the type retrieval of a const edge range (same as const_line_range) |
| const_element_range< MeshSegmentHandleType, element_type_or_tag > | Metafunction for the type retrieval of a const element range |
| const_element_view< something, element_type_or_tag, view_container_tag > | Returns a const view type for the provided element type or tag and the given container type selected for the view |
| const_facet_handle< SomethingT > | Metafunction for retrieving the const facet handle type an element, a mesh, a segmentation or a segment |
| const_facet_range< SomethingT > | Metafunction for retrieving the const facet range type an element, a mesh, a segmentation or a segment |
| const_handle< MeshSegmentHandleType, element_type_or_tag > | Metafunction for the type retrieval of a const element handle |
| const_handle_type< base_container_type, handle_tag > | |
| const_handle_type< base_container_type, id_handle_tag > | |
| const_handle_type< base_container_type, iterator_handle_tag > | |
| const_handle_type< base_container_type, no_handle_tag > | |
| const_handle_type< base_container_type, pointer_handle_tag > | |
| const_hexahedron_handle< SomethingT > | Convenience metafunction for the type retrieval of a const hexahedron handle |
| const_hexahedron_range< SomethingT > | Convenience metafunction for the type retrieval of a const hexahedron range |
| const_id< id_type > | |
| const_id< smart_id< value_type, id_type > > | |
| static_array< T, N >::const_iterator | |
| view< base_container_type_, container_tag >::const_iterator | |
| segmentation< WrappedConfigType >::const_iterator | Const iterator for iterating over all segments |
| segment_info_t< element_segment_mapping_type, container_tag >::const_iterator | |
| const_iterator< ContainerT > | Metafunction for the type retrieval of a const iterator from a container or range |
| const_iterator< base_iterator, base_const_iterator, id_handle_tag > | |
| const_iterator< base_iterator, base_const_iterator, iterator_handle_tag > | |
| const_iterator< base_iterator, base_const_iterator, no_handle_tag > | |
| const_iterator< base_iterator, base_const_iterator, pointer_handle_tag > | |
| const_line_handle< SomethingT > | Convenience metafunction for the type retrieval of a const line handle (same as const_edge_handle) |
| const_line_range< SomethingT > | Convenience metafunction for the type retrieval of a const line range (same as const_edge_range) |
| const_neighbor_range< MeshOrSegmentHandleT, ElementTypeOrTagT, ConnectorElementTypeOrTagT > | Metafunction for obtaining a const neighbor range of an element type with a connector element type within a mesh/segment |
| const_plc_handle< SomethingT > | Convenience metafunction for the type retrieval of a const plc handle |
| const_plc_range< SomethingT > | Convenience metafunction for the type retrieval of a const PLC range |
| const_polygon_handle< SomethingT > | Convenience metafunction for the type retrieval of a const polygon handle |
| const_polygon_range< SomethingT > | Convenience metafunction for the type retrieval of a const polygon range |
| const_quadrilateral_handle< SomethingT > | Convenience metafunction for the type retrieval of a const quadrilateral handle |
| const_quadrilateral_range< SomethingT > | Convenience metafunction for the type retrieval of a const quadrilateral range |
| view< base_container_type_, container_tag >::const_reverse_iterator | |
| const_tetrahedron_handle< SomethingT > | Convenience metafunction for the type retrieval of a const tetrahedron handle |
| const_tetrahedron_range< SomethingT > | Convenience metafunction for the type retrieval of a const tetrahedron range |
| const_triangle_handle< SomethingT > | Convenience metafunction for the type retrieval of a const triangle handle |
| const_triangle_range< SomethingT > | Convenience metafunction for the type retrieval of a const triangle range |
| const_vertex_handle< SomethingT > | Convenience metafunction for the type retrieval of a const vertex handle |
| const_vertex_range< SomethingT > | Convenience metafunction for the type retrieval of a const vertex range |
| container< base_container_, handle_tag_ > | |
| container< value_type, container_tag > | Returns a container for objects of the specified 'value_type' subject to the provided tag |
| container_base< base_container_, handle_tag > | |
| container_base< hidden_key_map< KeyT, ElementT >, handle_tag > | |
| container_base< std::set< key, compare, allocator >, handle_tag > | |
| container_collection< value_typelist, container_config > | Metafunction for obtaining the container collection for the provided value typelist and the respective container configuration |
| container_collection_typemap< SomethingT > | Metafunction for obtaining the container collection typemap of something |
| container_from_value_using_container_config< value_type, container_config > | |
| container_list_from_value_typelist_using_container_config< viennagrid::null_type, container_config > | |
| container_list_from_value_typelist_using_container_config< viennagrid::typelist< value_type, tail >, container_config > | |
| container_of< typemap_, element_type > | Returns the container type for a element from the type map configuration |
| container_output_functor | |
| container_range_wrapper< container_type > | |
| container_range_wrapper< const container_type > | |
| continuous_id_generator< typemap > | A generator which returns numerical IDs (of possibly different type) in a continuous fashion starting from zero for each requested type |
| continuous_id_generator_layer< viennagrid::null_type > | |
| continuous_id_generator_layer< viennagrid::typelist< viennagrid::static_pair< value_type, id_tag >, tail > > | |
| coord< SomethingT > | Metafunction for obtaining the coordinate type of the geometric point type of something |
| 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< spatial_point< CoordType, CoordinateSystem > > | Returns the coordinate system of a point. Specialization for a ViennaGrid point |
| copy_element_setters< MeshT, SourceElementT, DestinationElementT > | For internal use only |
| copy_elements_impl< ElementTagT > | |
| copy_elements_impl< plc_tag > | |
| copy_functor< predicate > | |
| copy_segmentation_functor< SourceMeshT, SourceSegmentationT, DestinationMeshT, DestinationSegmentationT > | Functor for copying a segmentation. For internal use only |
| cross_prod_impl< PointT, 1 > | Implementation of the cross product calculation in 1d for compatibility. Returns the zero-vector |
| cross_prod_impl< PointT, 2 > | Implementation of the cross product calculation in 2d for compatibility. Returns the zero-vector |
| cross_prod_impl< PointT, 3 > | Implementation of the cross product calculation in 3d |
| cs_base< CSystem > | Common base for all non-cartesian coordinate systems |
| cylindrical_cs | Provides the basic operations in a cylindrical coordinate system (rho, theta, z) |
| decorated_mesh_view_config< WrappedConfigType, ElementTypeList, ContainerConfig > | For internal use only |
| decorated_mesh_view_config< decorated_mesh_view_config< WrappedConfigType, E, C >, ElementTypeList, ContainerConfig > | For internal use only |
| default_container_tag< ElementTagT, boundary_cell_tag, VertexContainerT, CellContainerT > | Defines the default container tag for all elements in a domain. For vertices and cells specific given containers are used, for all others, hidden key maps are used to ensure the uniqueness of elements (taking orientation into account) |
| default_container_tag< ElementTagT, ElementTagT, VertexContainerT, CellContainerT > | |
| default_container_tag< ElementTagT, viennagrid::vertex_tag, VertexContainerT, CellContainerT > | |
| default_container_tag< viennagrid::vertex_tag, viennagrid::vertex_tag, VertexContainerT, CellContainerT > | |
| default_point_accessor< mesh_or_element_type > | Metafunction returning the default point accessor type for a vertex |
| dense_container_accessor< ContainerType, AccessType, UnpackT > | Implementation of an accessor for dense containers (most importantly std::vector, std::deque) which fulfills the accessor concept |
| dense_container_field< ContainerType, AccessType, UnpackT > | Accessor class implementing the field concept for dense containers (most importantly std::vector<> and std::deque<>) |
| dereference_handle_comparator< ContainerT > | For internal use only |
| dereference_handle_helper< HandleTagT > | |
| dereference_handle_helper< id_handle_tag > | |
| detect_interface_impl< false > | |
| detect_interface_impl< true > | |
| dimension< spatial_point< 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 |
| dual_for_each_functor< collection_type_1, collection_type_2, functor > | |
| DXHelper< DIM > | A helper class returning dimension-dependent attribute strings |
| DXHelper< 1 > | |
| DXHelper< 2 > | |
| DXHelper< 3 > | |
| dynamic_accessor_wrapper< AccessorType > | A dynamic accessor class which wraps any user accessor type fulfilling the accessor concept |
| dynamic_field_wrapper< FieldType, AccessType > | A dynamic accessor class which wraps any user accessor type fulfilling the field concept |
| dynamic_layout_tag | Tag that indicates that a dynamic container has to be used for storing the boundary element handles (e.g. polygon and plc) |
| edge< SomethingT > | Convenience metafunction for the type retrieval of a edge (same as line) |
| edge_handle< SomethingT > | Convenience metafunction for the type retrieval of a line handle (same as line_handle) |
| edge_id< SomethingT > | Convenience metafunction for the type retrieval of a line ID (same as line_id) |
| edge_range< SomethingT > | Convenience metafunction for the type retrieval of a edge range (same as line_range) |
| element< ElementTag, WrappedConfigType > | The main element class in ViennaGrid, representing vertices, edges, triangles, etc |
| element< MeshSegmentHandleType, element_type_or_tag > | Metafunction for the type retrieval of an element |
| element_boundary_element_container< WrappedConfigT, HostElementTagT, BoundaryElementTagT > | Creates the boundary element container and possible orientation container |
| element_boundary_element_container_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, is_present > | Helper meta function for creating the boundary element container using a wrapped config: a view for the boundary elements and a possible orientation container. Handles elements which are not present |
| element_boundary_element_container_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, false > | |
| element_boundary_element_container_helper< WrappedConfigT, HostElementTagT, vertex_tag, is_present > | |
| element_boundary_element_container_typelist< WrappedConfigT, HostElementTagT, BoundaryElementTagT > | Creates a typelist of all boundary container types for a given element tag using a wrapped config |
| element_boundary_element_container_typelist< WrappedConfigT, HostElementTagT, viennagrid::vertex_tag > | |
| element_collection< SomethingT > | Metafunction for obtaining the element collection of something |
| element_collection< WrappedConfigType > | Meta function for querying the element typelist for a mesh based on a wrapped config |
| element_container< WrappedConfigType, ElementTagT > | Creates a container for a specified ElementTagT for the mesh container collection based on a wrapped config. If a container collection is used as first argument, the container for the element with tag ElementTagT within the container collection is returned |
| element_container< collection< container_collection_typemap >, ElementTagT > | |
| element_container_typemap< WrappedConfigT, viennagrid::null_type > | |
| element_container_typemap< WrappedConfigT, viennagrid::typelist< viennagrid::static_pair< ElementTagT, ValueConfigT >, TailT > > | |
| element_extension< ElementTagT > | A class for injecting additional members into topological elements (Vertex, Edge, etc.) |
| element_key< element_type > | A key type that uniquely identifies an element by its vertices |
| element_key_tag | A tag for selecting element_key as a key type within metafunctions |
| element_orientation< container_type > | A permutator for mapping local orientations to global vertices of a boundary k-cell |
| element_range< MeshSegmentHandleType, element_type_or_tag > | Metafunction for the type retrieval of an element range |
| 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_segment_mapping< segment_id_type_, segment_element_info_type_ > | For internal use only |
| element_tag< ElementTypeOrTagT > | Metafunction for retrieving the tag of an element |
| 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 |
| element_taglist< SomethingT > | Metafunction for obtaining the element typelist of something |
| element_typelist< SomethingT > | Metafunction for obtaining the element typelist of something |
| element_view< something, element_type_or_tag, view_container_tag > | Returns a (non-const) view type for the provided element type or tag and the given container type selected for the view |
| elements_of_topologic_dim< something, topologic_dimension > | Metafunction for obtaining an element typelist of all element with a specific topologic dimension of something |
| EQUAL< type1, type2 > | |
| EQUAL< type, type > | |
| erase< null_type, to_erase > | |
| erase< typelist< head, tail >, to_erase > | |
| erase< typelist< static_pair< head_key, head_value >, tail >, to_erase > | |
| erase< typelist< to_erase, tail >, to_erase > | |
| erase_all< null_type, to_erase > | |
| erase_all< typelist< head, tail >, to_erase > | |
| erase_all< typelist< to_erase, tail >, to_erase > | |
| erase_at< null_type, index_to_erase > | |
| erase_at< typelist< head, tail >, 0 > | |
| erase_at< typelist< head, tail >, index_to_erase > | |
| erase_from_view_functor< MeshViewT > | |
| erase_functor< MeshT, MeshViewT > | For internal use only |
| facet< SomethingT > | Metafunction for retrieving the facet element type an element, a mesh, a segmentation or a segment |
| facet_handle< SomethingT > | Metafunction for retrieving the facet handle type an element, a mesh, a segmentation or a segment |
| facet_id< SomethingT > | Metafunction for retrieving the facet handle type an element, a mesh, a segmentation or a segment |
| facet_range< SomethingT > | Metafunction for retrieving the facet range type an element, a mesh, a segmentation or a segment |
| facet_tag< SomethingT > | Metafunction for retrieving the facet tag of an element, a mesh, a segmentation or a segment |
| find< typemap, to_find > | |
| find< null_type, to_find > | |
| find< typelist< static_pair< key, value >, tail >, to_find > | |
| find< typelist< static_pair< to_find, value >, tail >, to_find > | |
| first< pair > | |
| first< static_pair< first_, second_ > > | |
| fix_handle_helper< null_type > | |
| fix_handle_helper< typelist< SourceElementT, TailT > > | |
| for_each_boundary_element_functor< ElementT, FunctorT > | Helper functor which iterates over the respective boundary elements and applied the user-provided functor to each boundary element |
| for_each_element_functor< MeshSegmentHandleT, FunctorT > | For internal use only |
| for_each_functor< collection_type, functor > | |
| for_each_impl< typelist > | |
| for_each_impl< viennagrid::null_type > | |
| for_each_impl< viennagrid::typelist< head, tail > > | |
| forward_iterator_range< iterator_type > | |
| full_element_config< CellTagT, ElementTagT, HandleTagT, VertexContainerT, CellContainerT > | Creates the complete configuration for one element. ID tag is smart_id_tag<int>, element_container_tag is defined based default_container_tag meta function, boundary_storage_layout is defined based on storage_layout_config, no appendix type. For vertex no boundary storage layout is defined |
| full_element_config< CellTagT, viennagrid::vertex_tag, HandleTagT, VertexContainerT, CellContainerT > | |
| full_handling_tag | A tag denoting full storage of boundary elements of a certain topological element |
| full_lazy_handling_tag | A tag denoting lazy handling of boundary elements. Reserved for future use |
| full_mesh_config< CellTagT, PointType, HandleTagT, VertexContainerTagT, CellContainerTagT > | Meta function for creating a geometric configuration. A topologic configuration is created with the exception that the vertex appendix type is a given point type |
| full_mesh_config< CellTagT, void, HandleTagT, VertexContainerTagT, CellContainerTagT > | |
| full_topology_config< CellTagT, HandleTagT, VertexContainerTagT, CellContainerTagT > | Meta function for creating a topologic configuration |
| full_topology_config_helper< CellTagT, ElementTagT, HandleTagT, VertexContainerTagT, CellContainerTagT > | Helper meta function for creating topologic configuration using full_element_config for each element. Terminates at vertex level |
| full_topology_config_helper< CellTagT, viennagrid::vertex_tag, HandleTagT, VertexContainerTagT, CellContainerTagT > | |
| geometric_dimension< SomethingT > | Metafunction for obtaining the geometric dimension of something |
| handle< MeshSegmentHandleType, element_type_or_tag > | Metafunction for the type retrieval of an element handle |
| handle_functor< predicate > | |
| handle_helper< container_type, value_type, id_handle_tag > | |
| handle_helper< container_type, value_type, iterator_handle_tag > | |
| handle_helper< container_type, value_type, no_handle_tag > | |
| handle_helper< container_type, value_type, pointer_handle_tag > | |
| handle_mesh_functor< container_collection_type > | For internal use only |
| handle_or_ignore_helper< container_collection_type, handle_type, container_type > | |
| handle_or_ignore_helper< container_collection_type, handle_type, viennagrid::not_found > | |
| handle_tag< handle_type > | |
| handle_tag< smart_id< value_type_, base_id_type_ > > | |
| handle_tag< value_type * > | |
| handle_tag< viennagrid::null_type > | |
| handle_type< base_container_type, handle_tag > | |
| handle_type< base_container_type, id_handle_tag > | |
| handle_type< base_container_type, iterator_handle_tag > | |
| handle_type< base_container_type, no_handle_tag > | |
| handle_type< base_container_type, pointer_handle_tag > | |
| handled_container< base_container_, handle_tag > | |
| handled_container_tag< ContainerTagT, HandleTagT > | A tag indicating that a handled container is used |
| has_boundary< element_type, boundary_cell_type_or_tag > | Metafunction returning whether a certain element has a certain boundary cell type |
| has_boundary< WrappedConfigT, HostElementTagT, BoundaryElementTagT > | Determines if a given host element has a given boundary element using a wrapped config |
| has_boundary_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, is_present > | Helper class for has_boundary_cells, using dispatch if the host element is present |
| has_boundary_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, false > | |
| has_orientation< WrappedConfigT, HostElementTagT, BoundaryElementTagT > | Determines if orientation is available for a given host element and a given boundary element using a wrapped config |
| has_orientation_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, is_present > | Helper class for has_orientation, using dispatch if the host element is present |
| has_orientation_helper< WrappedConfigT, HostElementTagT, BoundaryElementTagT, false > | |
| hexahedral_3d | A default config for hexahedrons in 3d, pointer handles are used |
| hexahedron< SomethingT > | Convenience metafunction for the type retrieval of a hexahedron |
| hexahedron_handle< SomethingT > | Convenience metafunction for the type retrieval of a hexahedron handle |
| hexahedron_id< SomethingT > | Convenience metafunction for the type retrieval of a hexahedron ID |
| hexahedron_range< SomethingT > | Convenience metafunction for the type retrieval of a hexahedron range |
| hidden_key_map< KeyT, ValueT > | STL-like map where the key is automatically deduced from the value object (hence 'hidden') |
| hidden_key_map_const_iterator< HiddenKeyMapT > | A const-iterator over all values of a hidden_key_map |
| hidden_key_map_const_reverse_iterator< HiddenKeyMapT > | A const-iterator over all values of a hidden_key_map in reverse direction |
| hidden_key_map_iterator< HiddenKeyMapT > | An iterator over all values of a hidden_key_map |
| hidden_key_map_reverse_iterator< HiddenKeyMapT > | A iterator over all values of a hidden_key_map in reverse direction |
| hidden_key_map_tag< KeyTypeTagT > | A tag for selecting a hidden key map as a storage type |
| 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< some_type > | |
| id< ElementT > | Metafunction for obtaining the id type of an element |
| id_compare< id_type_ > | |
| id_generator< WrappedConfig > | Defines an ID generator based on a wrapped config |
| id_handle_tag | A tag defining that ID handles are used |
| id_handler< id_type_ > | |
| id_unpack | |
| IDCompare< ValueT > | |
| IDCompare< smart_id< ValueT, BaseIDType > > | |
| IDENTITY< T > | |
| IF< condition, type1, type2 > | |
| IF< false, type1, type2 > | |
| index_of< null_type, to_find > | |
| index_of< typelist< head, tail >, to_find > | |
| index_of< typelist< static_pair< key_type, value_type >, tail >, to_find > | |
| index_of< typelist< static_pair< to_find, value_type >, tail >, to_find > | |
| index_of< typelist< to_find, tail >, to_find > | |
| inf_norm_tag | Tag for denoting the infinity-norm |
| inner_prod_impl< PointT, 1 > | Implementation of the inner product in one dimension |
| inner_prod_impl< PointT, 2 > | Implementation of the inner product in two dimensions |
| inner_prod_impl< PointT, 3 > | Implementation of the inner product in three dimensions |
| insert< null_type, null_type > | |
| insert< null_type, static_pair< key, value > > | |
| insert< typelist< static_pair< map_key, map_value >, tail >, null_type > | |
| insert< typelist< static_pair< map_key, map_value >, tail >, static_pair< to_insert_key, to_insert_value > > | |
| insert_or_ignore_helper< container_collection_type, element_type, search_result > | |
| insert_or_ignore_helper< container_collection_type, element_type, viennagrid::not_found > | |
| insert_or_modify< typemap, to_modify > | |
| insert_or_modify< null_type, static_pair< key_to_find, modified_value > > | |
| insert_or_modify< typelist< static_pair< map_key, map_value >, tail >, null_type > | |
| insert_or_modify< typelist< static_pair< map_key, map_value >, tail >, static_pair< key_to_find, modified_value > > | |
| interface_information_collection_tag | A tag identifying interface information |
| interface_information_collection_typemap< element_taglist, segment_id_type, interface_information_container_tag, ChangeCounterType > | |
| interface_information_collection_typemap_impl< segment_id_type, interface_information_container_tag, ChangeCounterType, viennagrid::null_type > | |
| interface_information_collection_typemap_impl< segment_id_type, interface_information_container_tag, ChangeCounterType, viennagrid::typelist< element_tag, tail > > | |
| interface_information_wrapper< segment_id_type, container_type_, ChangeCounterType > | For internal use only |
| interface_setter_functor< SegmentationT > | For internal use only |
| intersection< typelist1, typelist2 > | |
| intersection< null_type, null_type > | |
| intersection< null_type, typelist< head2, tail2 > > | |
| intersection< typelist< head1, tail1 >, null_type > | |
| intersection< typelist< head1, tail1 >, typelist< head2, tail2 > > | |
| is_boundary< HostElementT, BoundaryElementTypeOrTagT > | Metafunction for query if an element type/tag is boundary element of another host element |
| is_const_iterator< TIterator > | |
| is_const_pointer< T > | |
| is_const_pointer< const T * > | |
| is_element_present< WrappedConfigType, element_tag > | Determines if a given element tag is present within a wrapped config |
| view< base_container_type_, container_tag >::iterator | |
| static_array< T, N >::iterator | |
| segmentation< WrappedConfigType >::iterator | Iterator for iterating over all segments |
| iterator< ContainerT > | Metafunction for the type retrieval of an iterator from a container or range |
| iterator< base_iterator, base_const_iterator, id_handle_tag > | |
| iterator< base_iterator, base_const_iterator, iterator_handle_tag > | |
| iterator< base_iterator, base_const_iterator, no_handle_tag > | |
| iterator< base_iterator, base_const_iterator, pointer_handle_tag > | |
| iterator_handle_tag | A tag defining that iterator handles are used |
| key_typelist< viennagrid::null_type > | |
| key_typelist< viennagrid::typelist< viennagrid::static_pair< key_, value_ >, tail > > | |
| lexical_cast_impl< DestinationT > | |
| lexical_cast_impl< boolalpha_bool > | |
| line< SomethingT > | Convenience metafunction for the type retrieval of a line (same as edge) |
| line_1d | A default config for lines in 1d, pointer handles are used |
| line_2d | A default config for lines in 2d, pointer handles are used |
| line_3d | A default config for lines in 3d, pointer handles are used |
| line_handle< SomethingT > | Convenience metafunction for the type retrieval of a line handle (same as edge_handle) |
| line_id< SomethingT > | Convenience metafunction for the type retrieval of a line ID (same as edge_id) |
| line_range< SomethingT > | Convenience metafunction for the type retrieval of a line range (same as edge_range) |
| lookup< typemap, to_find > | |
| lookup< viennagrid::collection< typemap >, key_type > | |
| make_element_impl< ElementTagT > | |
| make_element_impl< plc_tag > | |
| make_id< value_type, id_tag< id_type > > | |
| make_id< value_type, smart_id_tag< base_id_type > > | |
| make_typelist< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > | Convenience meta function for creating a typelist out of the provided types |
| mark_referencing_elements_impl< MeshT, ToEraseViewT, HandleT, viennagrid::null_type > | For internal use only |
| mark_referencing_elements_impl< MeshT, ToEraseViewT, HandleT, viennagrid::typelist< CoboundaryElementT, TailT > > | |
| merge< typemap, typemap_to_merge > | |
| merge_helper_error< to_insert, search_result > | |
| merge_helper_error< to_insert, not_found > | |
| merge_helper_ignore< to_insert, search_result > | |
| merge_helper_ignore< to_insert, not_found > | |
| merge_helper_overwrite< to_insert, search_result > | |
| merge_ignore< typemap, typemap_to_merge > | |
| merge_impl< null_type, null_type, merge_helper > | |
| merge_impl< null_type, typelist< static_pair< key2, value2 >, tail2 >, merge_helper > | |
| merge_impl< typelist< static_pair< key1, value1 >, tail1 >, null_type, merge_helper > | |
| merge_impl< typelist< static_pair< key1, value1 >, tail1 >, typelist< static_pair< key2, value2 >, tail2 >, merge_helper > | |
| merge_overwrite< typemap, typemap_to_merge > | |
| mesh< WrappedConfigType > | Metafunction for obtaining a mesh from a config |
| mesh< WrappedConfigType > | The main mesh class holding all the different elements. The data structure is configured using a configuration class. See viennagrid::config for predefined configurations |
| mesh< viennagrid::segment_handle< SegmentationT > > | Meta function for querying the mesh type of a segment handle |
| mesh< viennagrid::segmentation< WrappedConfigType > > | Meta function for querying the mesh type of a segmentation |
| mesh_proxy< MeshT > | Proxy object for a mesh. This is used for wrapping a mesh/mesh view when creating a view |
| mesh_serializer< MeshT > | Mesh wrapper which models the Boost serialization concept |
| mesh_view< MeshT, Element0TypeOrTagT, Element1TypeOrTagT, Element2TypeOrTagT, Element3TypeOrTagT, Element4TypeOrTagT, Element5TypeOrTagT, Element6TypeOrTagT, Element7TypeOrTagT, Element8TypeOrTagT, Element9TypeOrTagT > | Metafunction for obtaining a mesh view from a mesh. Elements can be directly given. If viennagrid::null_type is specified somewhere all following types will be ignored. The default type for all element types is viennagrid::null_type |
| mesh_view_from_typelist< MeshT, ElementTypelistT, ContainerConfigT > | Metafunction for obtaining a mesh view from a mesh using an element type list and a container configuration |
| modify< typemap, to_modify > | |
| modify< null_type, static_pair< key_to_find, modified_value > > | |
| modify< typelist< static_pair< map_key, map_value >, tail >, null_type > | |
| modify< typelist< static_pair< map_key, map_value >, tail >, static_pair< key_to_find, modified_value > > | |
| mphtxt_writer | Writer for Comsol .mphtxt files |
| n_over_k< n, k > | |
| n_over_k< 0, 0 > | |
| n_over_k< 0, k > | |
| n_over_k< n, 0 > | |
| bnd_helper::negate | |
| neighbor_collection_tag | A tag for identifying the neighbor element collection |
| neighbor_container_collection_per_element_typemap< WrappedConfigType, ElementTagT, BoundaryElementTaglistT > | Creates the typemap for the neighbor container collection based on an element and its boundary element typelist. The boundary elements are used as connector elements |
| neighbor_container_collection_typemap< WrappedConfigType, ElementTaglistT > | Creates the typemap for the neighbor container collection for all elements by merging all typemaps created by neighbor_container_collection_per_element_typemap |
| neighbor_container_wrapper< container_type_, change_counter_type > | For internal use only |
| neighbor_range< MeshOrSegmentHandleT, ElementTypeOrTagT, ConnectorElementTypeOrTagT > | Metafunction for obtaining a neighbor range of an element type with a connector element type within a mesh/segment |
| neighbor_range_wrapper< ElementTypeOrTagT, ConnectorElementTypeOrTagT, ContainerT > | |
| neighbor_range_wrapper< ElementTypeOrTagT, ConnectorElementTypeOrTagT, const ContainerT > | |
| neper_tess_reader | Reader for Neper .tess files |
| netgen_reader | Reader for Netgen files obtained from the 'Export mesh...' menu item. Tested with Netgen version 4.9.12 |
| no_duplicates< null_type > | |
| no_duplicates< typelist< head, tail > > | |
| no_handle_tag | A tag defining that no handles are used |
| no_handling_tag | A tag denoting that the boundary elements should not be stored at all |
| no_orientation_handling_tag | A tag denoting that the boundary elements should stored without orientation |
| no_orientation_lazy_handling_tag | A tag denoting that orientation should be stored/computed only on request ('lazy') |
| non_recursive_erase_functor< SegmentHandleT > | |
| norm_impl< Tag > | |
| norm_impl< viennagrid::inf_norm_tag > | Implementation of the inf-norm |
| norm_impl< viennagrid::one_norm_tag > | Implementation of the 1-norm |
| norm_impl< viennagrid::two_norm_tag > | Implementation of the 2-norm |
| NOT_EQUAL< type1, type2 > | |
| not_found | Empty type indicating that an element in a typelist/typemap wasn't found |
| null_type | An empty type, used within typelists and typemaps |
| numeric_type< NumericConfigT, OuterNumericT > | |
| numeric_type< double, OuterNumericT > | |
| one_norm_tag | Tag for denoting the 1-norm |
| opendx_writer< MeshType > | The OpenDX writer object. Does not support segments - always the full mesh is written |
| oriented_3d_hull_segmentation< MeshT, ViewT, SegmentIDType, AppendixType, view_container_tag > | Metafunction for obtaining a segmentation type for a 3D hull mesh type and with settings. Segment element information is a bool (see segment_element_info for more information) |
| out_of_range | Empty type used to indicate that an element in a typelist/typemap is out of range |
| permutator_type< num_elements > | Returns the internal type used for element permutations from global to local ordering |
| physical_inserter< container_collection_type, change_counter_type, id_generator_type_ > | An inserter class which adds elements to a the provided container collection. For example, this inserts a triangle into a segment s, but not into the mesh or segment where s was derived from |
| physical_inserter< container_collection_type, change_counter_type, id_generator_type > | Helper metafunction for obtaining the physical inserter for a container collection. Inserts an element, not just a reference |
| plc< SomethingT > | Convenience metafunction for the type retrieval of a plc |
| plc_3d | A default config for PLCs in 2d, pointer handles are used |
| plc_handle< SomethingT > | Convenience metafunction for the type retrieval of a plc handle |
| plc_id< SomethingT > | Convenience metafunction for the type retrieval of a plc ID |
| plc_range< SomethingT > | Convenience metafunction for the type retrieval of a PLC range |
| plc_tag | A tag for identifying piecewise linear complexes (PLCs) |
| point< SomethingT > | Metafunction for obtaining the geometric point type of something |
| 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_exception | An exception class for invalid point indices |
| 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 |
| pointer_handle_tag | A tag defining that pointer handles are used |
| 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_cs | Provides the basic operations in a polar coordinate system (r, phi) |
| polygon< SomethingT > | Convenience metafunction for the type retrieval of a polygon |
| polygon_handle< SomethingT > | Convenience metafunction for the type retrieval of a polygon handle |
| polygon_id< SomethingT > | Convenience metafunction for the type retrieval of a polygon v |
| polygon_range< SomethingT > | Convenience metafunction for the type retrieval of a polygon range |
| polygon_tag | A tag representing polygons |
| polygonal_2d | A default config for polygons in 2d, pointer handles are used |
| polygonal_3d | A default config for polygons in 3d, pointer handles are used |
| print | |
| push_back< null_type, null_type > | |
| push_back< null_type, to_add > | |
| push_back< typelist< head, tail >, to_add > | |
| push_back_list< null_type, null_type > | |
| push_back_list< null_type, typelist< head, tail > > | |
| push_back_list< typelist< head, tail >, null_type > | |
| push_back_list< typelist< head1, tail1 >, typelist< head2, tail2 > > | |
| quadrilateral< SomethingT > | Convenience metafunction for the type retrieval of a quadrilateral |
| quadrilateral_2d | A default config for quadrilaterals in 2d, pointer handles are used |
| quadrilateral_3d | A default config for quadrilaterals in 3d, pointer handles are used |
| quadrilateral_handle< SomethingT > | Convenience metafunction for the type retrieval of a quadrilateral handle |
| quadrilateral_id< SomethingT > | Convenience metafunction for the type retrieval of a quadrilateral ID |
| quadrilateral_range< SomethingT > | Convenience metafunction for the type retrieval of a quadrilateral range |
| quantity_transfer_dispatcher< SourceTag, DestinationTag, less_than, larger_than > | |
| quantity_transfer_dispatcher< SourceTag, DestinationTag, false, true > | |
| quantity_transfer_dispatcher< SourceTag, DestinationTag, true, false > | |
| query_appendix_type< WrappedConfigType, element_tag > | Queries the appendix type for a given element tag from a wrapped config. PLC appendix type is std::vector<PointType> for holes. Default is null_type |
| query_appendix_type< WrappedConfigType, plc_tag > | |
| query_element_container_tag< WrappedConfigType, element_tag > | Queries the container tag for a given element tag from a wrapped config, default is std::deque with pointer handle |
| query_element_id_tag< WrappedConfigType, element_tag > | Queries the element id tag for a given element tag from a wrapped config, default is smart_id_tag<int> |
| recursive_inserter< container_collection_type, change_counter_type, dependent_inserter_type > | Helper metafunction for obtaining the recursive inserter type for a container collection |
| recursive_inserter< view_collection_type, change_counter_type, dependent_inserter_type > | Recursive inserter which inserts an element into the provided collection and all dependent collections |
| referencing_element_typelist< SomethingT, ElementTypeOrTagT > | Metafunction for obtaining the an element typelist including all element which references a given element. e.g. in a default triangle mesh the referencing element typelist based on the mesh for a vertex contains a line type and a triangle type. The host type can also be an element in which case all boundary elements referening the given element are returned (in a default tetrahedron mesh the referencing elements for a vertex based on a triangle contains only a line type) |
| remove_const< some_type > | |
| remove_const< const some_type > | |
| replace< null_type, to_replace, replaced > | |
| replace< typelist< head, tail >, to_replace, replaced > | |
| replace< typelist< to_replace, tail >, to_replace, replaced > | |
| replace_all< null_type, to_replace, replaced > | |
| replace_all< typelist< head, tail >, to_replace, replaced > | |
| replace_all< typelist< to_replace, tail >, to_replace, replaced > | |
| replace_at< null_type, index_to_replace, replaced > | |
| replace_at< null_type,-1, replaced > | |
| replace_at< typelist< head, tail >, 0, replaced > | |
| replace_at< typelist< head, tail >, index_to_replace, replaced > | |
| replace_at< typelist< head, tail >,-1, replaced > | |
| reverse< null_type > | |
| reverse< typelist< head, tail > > | |
| view< base_container_type_, container_tag >::reverse_iterator | |
| scale_functor< MeshT > | Scale functor with scaling factor and scale center |
| second< pair > | |
| second< static_pair< first_, second_ > > | |
| seg_cell_normal_data | Data type for cell normals in algorithm/cell_normals.hpp (to be added in a future release) |
| seg_cell_normal_tag | Types for cell normals in algorithm/cell_normals.hpp (to be added in a future release) |
| segment_handle< viennagrid::segmentation< WrappedConfigType > > | A segment defines a submesh within a segmentation. The segment_handle is used to deal with segments, since segments are not represented by a dedicated class |
| segment_id_not_found_exception | Provides an exception for the case a segment id cannot be found |
| segment_id_range< SegmentationT, ElementTypeOrTagT > | Defines a range of segment IDs which represents segments in which an element is included |
| segment_id_range_t< SegmentInfoT > | Defines a range of segment IDs which represents segments in which an element is included, use result_of::segment_id_range for defining this type |
| segment_info_t< element_segment_mapping_type, container_tag > | Information container providing iteration over segments of a segmentation |
| segment_interface_information_wrapper< container_type_, ChangeCounterType > | For internal use only |
| segment_name_collision_exception | Provides an exception for the case of a name collision of segment names |
| segment_name_not_found_exception | Provides an exception for the case a segment name cannot be found |
| segmentation< WrappedConfigType > | A segmentation is a logical decomposition of the mesh (or a subset thereof) into segments. Segments may overlap |
| segmentation< MeshT, ViewT, SegmentIDType, AppendixType, view_container_tag > | Metafunction for obtaining a segmentation type for a mesh type and with settings. Segment element information is not present (see segment_element_info for more information) |
| segmentation< viennagrid::segment_handle< const SegmentationT > > | |
| segmentation< viennagrid::segment_handle< SegmentationT > > | Returns the underlying segmentation type from a segment_handle (Segment) object |
| segmentation_info_container_typemap< viennagrid::null_type, segment_id_type, container_tag, segment_info_container_tag > | |
| segmentation_info_container_typemap< viennagrid::typelist< viennagrid::static_pair< element_tag, segment_info_type >, tail >, segment_id_type, container_tag, segment_info_container_tag > | |
| segmented_mesh< MeshT, SegmentationT > | A segmented_mesh is a mesh together with a segmentation |
| segmented_mesh< viennagrid::mesh< WrappedMeshConfig >, viennagrid::segmentation< WrappedSegmentationConfig > > | A specialization for viennagrid meshes and segmentation |
| set | |
| signed_spanned_volume_impl< PointT, 1 > | Implementation of the volume spanned by two points in one dimension |
| signed_spanned_volume_impl< PointT, 2 > | Implementation of the volume of simplices spanned by points in two geometrical dimension |
| signed_spanned_volume_impl< PointT, 3 > | Implementation of the volume of simplices spanned by points in three geometrical dimension |
| simplex_tag< n > | Topological description of an n-simplex |
| simplex_tag< 0 > | Topological description of a 0-cell (vertex) |
| size< null_type > | |
| size< typelist< head, tail > > | |
| smart_id< value_type_, base_id_type_ > | |
| smart_id< const value_type_, base_id_type_ > | |
| spatial_point< CoordType, CoordinateSystem > | Main point class of ViennaGrid. Represents a geometric location inside the respective Euclidian space |
| spherical_cs | Provides the basic operations in a spherical coordinate system (r, theta, phi) with theta denoting the elevation angle |
| static_array< T, N > | Reimplementation of std::array<> because we cannot reasonably expect that C++11 is available on all target machines |
| static_array_tag< SizeV > | A tag indicating that storage::static_array should be used |
| STATIC_ASSERT< ErrorT > | |
| STATIC_ASSERT< false > | |
| static_layout_tag | Tag that indicates that a static container can be used for storing the boundary element handles (e.g. used in simplices and hypercubes) |
| static_pair< FirstT, SecondT > | A static pair time. To be seen as the equivalent of std::pair<>, but for metaprogramming |
| static_size< spatial_point< CoordType, CoordinateSystem > > | Returns the static (compile time) size of a point. Specialization for a ViennaGrid point |
| std_map_accessor< ContainerType, AccessType, UnpackT > | An accessor (fulfilling the accessor concept) for a container of interface similar to std::map<> |
| std_map_field< ContainerType, AccessType, UnpackT > | An accessor (fulfilling the field concept) for a container of interface similar to std::map<> |
| storage_layout_config< ElementTagT, boundary_cell_tag > | Defines the default storage layout for elements: full handling tag is default except for vertex, which don't have orientation |
| storage_layout_config< ElementTagT, viennagrid::null_type > | |
| storage_layout_config< ElementTagT, viennagrid::vertex_tag > | |
| strChecker | Checks for a string being a number |
| switch_handle_functor< MeshT, ToSwtichElementHandleT > | For internal use only |
| tag< foo > | |
| tetgen_poly_reader | Reader for Tetgen .poly files |
| tetrahedral_3d | A default config for tetrahedrons in 3d, pointer handles are used |
| tetrahedron< SomethingT > | Convenience metafunction for the type retrieval of a tetrahedron |
| tetrahedron_handle< SomethingT > | Convenience metafunction for the type retrieval of a tetrahedron handle |
| tetrahedron_id< SomethingT > | Convenience metafunction for the type retrieval of a tetrahedron ID |
| tetrahedron_range< SomethingT > | Convenience metafunction for the type retrieval of a tetrahedron range |
| thin_hexahedral_3d | A minimal configuration for hexahedra in 3d, no facts or edges |
| thin_mesh_config< CellTagT, PointType, HandleTagT, VertexContainerTagT, CellContainerTagT > | Meta function for creating a geometric configuration with thin topology. A thin topologic configuration is created with the exception that the vertex appendix type is a given point type |
| thin_mesh_config< CellTagT, void, HandleTagT, VertexContainerTagT, CellContainerTagT > | |
| thin_quadrilateral_2d | A minimal configuration for quadrilaterals in 2d, no facts/edges |
| thin_quadrilateral_3d | A minimal configuration for quadrilaterals in 3d, no facts/edges |
| thin_tetrahedral_3d | A minimal configuration for tetrahedra in 3d, no facts or edges |
| thin_topology_config< CellTagT, HandleTagT, VertexContainerTagT, CellContainerTagT > | Meta function for creating a thin topologic configuration. A thin topology only holds cells and vertices, but no facets, etc |
| thin_triangular_2d | A minimal configuration for triangles in 2d, no facts/edges |
| thin_triangular_3d | A minimal configuration for triangles in 3d, no facts/edges |
| topologic_cell_dimension< something > | Metafunction for returning the topologic dimension of the cell in a mesh or segment |
| topologic_dimension< element_type_or_tag > | Returns the topologic dimension of a certain element (identified by its type or tag) |
| topological_id< T > | |
| topological_id< segment_handle< SegmentationT > > | |
| topological_id< spatial_point< CoordT, CoordinateSystemT > > | |
| topological_id< viennagrid::element< hypercube_tag< dim >, WrappedConfigT > > | |
| topological_id< viennagrid::element< simplex_tag< dim >, WrappedConfigT > > | |
| topological_id< viennagrid::mesh< WrappedConfigT > > | |
| topologically_sorted< T, U > | |
| TRANSFORM< functor, viennagrid::null_type > | |
| TRANSFORM< functor, viennagrid::typelist< head, tail > > | |
| triangle< SomethingT > | Convenience metafunction for the type retrieval of a triangle |
| triangle_handle< SomethingT > | Convenience metafunction for the type retrieval of a triangle handle |
| triangle_id< SomethingT > | Convenience metafunction for the type retrieval of a triangle ID |
| triangle_information< TriangleHandleT > | |
| triangle_range< SomethingT > | Convenience metafunction for the type retrieval of a triangle range |
| triangular_2d | A default config for triangles in 2d, pointer handles are used |
| triangular_3d | A default config for triangles in 3d, pointer handles are used |
| trivial_segmentation_appendix< viennagrid::null_type, segment_id_type, container_tag > | |
| trivial_segmentation_appendix< viennagrid::typelist< element_type, tail >, segment_id_type, container_tag > | |
| true_functor | A trivial functor which always returns true |
| true_predicate | |
| two_norm_tag | Tag for denoting the 2-norm |
| typelist< HeadT, TailT > | Implementation of a typelist as described by Alexandrescu in his book "Modern C++ Programming" |
| unchecked_add_functor< SegmentT > | For internal use only |
| unpack< const std::deque< T, Alloc > > | |
| unpack< const std::map< Key, T, Compare, Alloc > > | |
| unpack< const std::vector< T, Alloc > > | |
| unpack< std::deque< T, Alloc > > | |
| unpack< std::map< Key, T, Compare, Alloc > > | |
| unpack< std::vector< T, Alloc > > | |
| unpack_second< ConfigEntryT > | A simple meta function for unpacking the value of a search result |
| unpack_second< viennagrid::not_found > | |
| value_type< handle_type > | |
| value_type< const value_type_ * > | |
| value_type< smart_id< const value_type_, base_id_type_ > > | |
| value_type< smart_id< value_type_, base_id_type_ > > | |
| value_type< value_type_ * > | |
| value_typelist< viennagrid::null_type > | |
| value_typelist< viennagrid::typelist< viennagrid::static_pair< key_, value_ >, tail > > | |
| ValueTypeInformation< double > | |
| ValueTypeInformation< std::vector< double > > | |
| vertex< SomethingT > | Convenience metafunction for the type retrieval of a vertex |
| vertex_1d | A default config for vertices in 1d, pointer handles are used |
| vertex_2d | A default config for vertices in 2d, pointer handles are used |
| vertex_3d | A default config for vertices in 3d, pointer handles are used |
| vertex_copy_map< SrcMeshT, DstMeshT > | A helper class for element copy operation between two differen meshes |
| vertex_handle< SomethingT > | Convenience metafunction for the type retrieval of a vertex handle |
| vertex_id< SomethingT > | Convenience metafunction for the type retrieval of a vertex ID |
| vertex_range< SomethingT > | Convenience metafunction for the type retrieval of a vertex range |
| 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 |
| view< base_container_type_, container_tag > | A view holds references to a subset of elements in another elements, but represents itself to the outside as another container |
| view< base_container_type, view_container_tag > | Metafunction for returning a view on a container using the respective container for holding the references inside the view |
| view_mesh_setter< container_collection_type > | For internal use only |
| vmesh_writer< MeshType, SegmentationType > | Main VMesh writer class. Writes a mesh or a segment to a file |
| voronoi_cell_contribution< ConstCellHandleT > | Returns the internal type used for the individual Voronoi quantity contributions |
| vtk_reader< MeshType, SegmentationType > | 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_writer< MeshType, SegmentationType > | Main VTK writer class. Writes a mesh or a segment to a file |
| wrapped_mesh_config_t< CellTagT, PointTypeT, HandleTagT, VertexContainerTagT, CellContainerTagT > | A generic config wrapper for mesh configs |
| xml_tag< dummy > | Helper class that parses a XML tag |
