Data Structures | Namespaces | Defines | Typedefs | Functions

/export/development/ViennaGrid/release/ViennaGrid-1.0.0/viennagrid/forwards.h File Reference

Contains forward declarations and definition of small classes that must be defined at an early stage. More...

#include <iostream>
#include <vector>
#include <map>
#include <cstddef>
#include <cstdlib>
#include "viennadata/api.hpp"

Go to the source code of this file.

Data Structures

struct  dimension_tag< d >
 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< T, dim >
 A key used for ViennaData to store coboundary information on n-cells. More...
class  segment_mapping_key< SegmentType >
class  const_ncell_proxy< T >
 A proxy class for retrieving const n-cell ranges. More...
class  ncell_proxy< T >
 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  bndcells< ElementTag, level >
 Holds the topological information about boundary cells for a n-cell. More...
struct  bndcell_filler< ElementTag, k >
 Worker class that sets up the boundary k-cells of a n-cell. More...
struct  element_id_handler< ConfigType, ElementTag >
 Metafunction that returns the ID handling class of an n-cell. More...
struct  config< T >
 Metafunction returning the configuration class of a topological element. More...
struct  config< domain_t< ConfigType > >
 Metafunction returning the configuration class of a topological element. Specialization for a domain. More...
struct  config< segment_t< ConfigType > >
 Metafunction returning the configuration class of a topological element. Specialization for a segment. More...
struct  config< element_t< ConfigType, ElementTag > >
 Metafunction returning the configuration class of a topological element. Specialization for a n-cell. More...
struct  ncell< Config, dim, cell_level >
 Metafunction for the type retrieval of n-cells. More...
struct  ncell< Config, cell_level, cell_level >
 Metafunction for the type retrieval of n-cells. Specialization for the cells. More...
struct  point< Config >
 Metafunction returning the type of a geometric point as used by vertices of the domain. More...
struct  bndcell_orientation< ConfigType, T, dim >
 Metafunction for local-to-global-orienters: By default, orienters are stored on n-cells. More...
struct  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. More...
struct  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). More...
struct  bndcell_handling< ConfigType, domain_t< ConfigType >, dim >
 Specialization of the k-cell handling for the domain. More...
struct  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). More...
struct  bndcell_handling< ConfigType, segment_t< ConfigType >, dim >
 Specialization of the k-cell handling for segments. More...
struct  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). 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...

Namespaces

namespace  viennagrid
 

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


namespace  viennagrid::topology
 

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


namespace  viennagrid::result_of
 

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


namespace  viennagrid::detail
 

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


Defines

#define VIENNAGRID_DISABLE_BOUNDARY_NCELL(arg_CONFIG, arg_TAG, arg_DIM)
 Convenience macro for disabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_ENABLE_BOUNDARY_NCELL(arg_CONFIG, arg_TAG, arg_DIM)
 Convenience macro for enabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_GLOBAL_DISABLE_BOUNDARY_NCELL(arg_TAG, arg_DIM)
 Convenience macro for disabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG for all configuration classes.
#define VIENNAGRID_DISABLE_BOUNDARY_NCELL_ORIENTATION(arg_CONFIG, arg_TAG, arg_DIM)
 Convenience macro for disabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_ENABLE_BOUNDARY_NCELL_ORIENTATION(arg_CONFIG, arg_TAG, arg_DIM)
 Convenience macro for enabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_GLOBAL_DISABLE_BOUNDARY_NCELL_ORIENTATION(arg_TAG, arg_DIM)
 Convenience macro for disabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG for all configuration classes.
#define VIENNAGRID_DISABLE_NCELL_ID(arg_CONFIG, arg_TAG)
 Convenience macro for disabling the storage of an ID for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_ENABLE_NCELL_ID(arg_CONFIG, arg_TAG)
 Convenience macro for enabling the storage of an ID for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.
#define VIENNAGRID_GLOBAL_DISABLE_NCELL_ID(arg_TAG)
 Convenience macro for disabling the storage of an ID for a n-cell identified by arg_TAG for all configuration classes.
#define VIENNAGRID_DISABLE_DOMAIN_NCELL(arg_CONFIG, arg_DIM)
 Disable the storage of n-cells for the domain with a certain configuration class arg_CONFIG. Requires disabled storage of boundary n-cells.
#define VIENNAGRID_ENABLE_DOMAIN_NCELL(arg_CONFIG, arg_DIM)
 Selectively enable the storage of n-cells for the domain with a certain configuration class arg_CONFIG.
#define VIENNAGRID_GLOBAL_DISABLE_DOMAIN_NCELL(arg_DIM)
 Disable the storage of n-cells for the domain for all configuration classes. Requires disabled storage of boundary n-cells.
#define VIENNAGRID_ENABLE_NCELL_ID_FOR_DATA(arg_CONFIG, arg_CELLTAG)
 Enable the use of the n-cell ID for ViennaData for a certain configuration class arg_CONFIG. Required for dense storage with ViennaData. arg_CELLTAG denotes the n-cell tag.
#define VIENNAGRID_ENABLE_ALL_NCELL_ID_FOR_DATA(arg_CONFIG)
 Enable the use of the n-cell ID for ViennaData for all n-cells using a certain configuration class arg_CONFIG. Required for dense storage with ViennaData.
#define VIENNAGRID_GLOBAL_ENABLE_NCELL_ID_FOR_DATA(arg_CELLTAG)
 Enable the use of the n-cell ID for ViennaData for n-cells identified by the tag arg_CELLTAG, irrespective of the configuration class. Required for dense storage with ViennaData.
#define VIENNAGRID_GLOBAL_ENABLE_ALL_NCELL_ID_FOR_DATA()
 Enable the use of the n-cell ID for ViennaData for all n-cells and all configuration classes. Required for dense storage with ViennaData.

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<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 >
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 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<typename ConfigTypeIn , typename ConfigTypeOut >
void refine_impl (domain_t< ConfigTypeIn > const &domain_in, domain_t< ConfigTypeOut > &domain_out, uniform_refinement_tag)
 Implementation of uniform refinement. Responsible for all the book-keeping.
template<typename ConfigTypeIn , typename ConfigTypeOut >
void refine_impl (domain_t< ConfigTypeIn > const &domain_in, domain_t< ConfigTypeOut > &domain_out, local_refinement_tag)
 Implementation of adaptive refinement. Responsible for all the book-keeping.

Detailed Description

Contains forward declarations and definition of small classes that must be defined at an early stage.


Define Documentation

#define VIENNAGRID_DISABLE_BOUNDARY_NCELL (   arg_CONFIG,
  arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_handling<arg_CONFIG, arg_TAG, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Convenience macro for disabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_DISABLE_BOUNDARY_NCELL_ORIENTATION (   arg_CONFIG,
  arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_orientation<arg_CONFIG, arg_TAG, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Convenience macro for disabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_DISABLE_DOMAIN_NCELL (   arg_CONFIG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_handling<arg_CONFIG, domain_t<arg_CONFIG>, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Disable the storage of n-cells for the domain with a certain configuration class arg_CONFIG. Requires disabled storage of boundary n-cells.

#define VIENNAGRID_DISABLE_NCELL_ID (   arg_CONFIG,
  arg_TAG 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct element_id_handler<arg_CONFIG, arg_TAG> { \
      typedef pointer_id    type; \
    }; \
 } }

Convenience macro for disabling the storage of an ID for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_ENABLE_ALL_NCELL_ID_FOR_DATA (   arg_CONFIG  ) 
Value:
namespace viennadata { namespace config { \
    template <typename CellTag> struct object_identifier<viennagrid::element_t<arg_CONFIG, CellTag> >  { \
      typedef object_provided_id    tag; \
      typedef size_t                id_type; \
      static size_t get(viennagrid::element_t<arg_CONFIG, CellTag> const & obj) { return obj.id(); } \
    };  }  }

Enable the use of the n-cell ID for ViennaData for all n-cells using a certain configuration class arg_CONFIG. Required for dense storage with ViennaData.

#define VIENNAGRID_ENABLE_BOUNDARY_NCELL (   arg_CONFIG,
  arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_handling<arg_CONFIG, arg_TAG, arg_DIM> { \
      typedef full_handling_tag    type; \
    }; \
 } }

Convenience macro for enabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_ENABLE_BOUNDARY_NCELL_ORIENTATION (   arg_CONFIG,
  arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_orientation<arg_CONFIG, arg_TAG, arg_DIM> { \
      typedef full_handling_tag    type; \
    }; \
 } }

Convenience macro for enabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_ENABLE_DOMAIN_NCELL (   arg_CONFIG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct bndcell_handling<arg_CONFIG, domain_t<arg_CONFIG>, arg_DIM> { \
      typedef full_handling_tag    type; \
    }; \
 } }

Selectively enable the storage of n-cells for the domain with a certain configuration class arg_CONFIG.

#define VIENNAGRID_ENABLE_NCELL_ID (   arg_CONFIG,
  arg_TAG 
)
Value:
namespace viennagrid { namespace result_of { \
    template <> \
    struct element_id_handler<arg_CONFIG, arg_TAG> { \
      typedef integral_id    type; \
    }; \
 } }

Convenience macro for enabling the storage of an ID for a n-cell identified by arg_TAG when used with a certain configuration class arg_CONFIG.

#define VIENNAGRID_ENABLE_NCELL_ID_FOR_DATA (   arg_CONFIG,
  arg_CELLTAG 
)
Value:
namespace viennadata { namespace config { \
    template <> struct object_identifier<viennagrid::element_t<arg_CONFIG, arg_CELLTAG> >  { \
      typedef object_provided_id    tag; \
      typedef size_t                id_type; \
      static size_t get(viennagrid::element_t<arg_CONFIG, arg_CELLTAG> const & obj) { return obj.id(); } \
    };  }  }

Enable the use of the n-cell ID for ViennaData for a certain configuration class arg_CONFIG. Required for dense storage with ViennaData. arg_CELLTAG denotes the n-cell tag.

#define VIENNAGRID_GLOBAL_DISABLE_BOUNDARY_NCELL (   arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <typename ConfigType> \
    struct bndcell_handling<ConfigType, arg_TAG, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Convenience macro for disabling boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG for all configuration classes.

#define VIENNAGRID_GLOBAL_DISABLE_BOUNDARY_NCELL_ORIENTATION (   arg_TAG,
  arg_DIM 
)
Value:
namespace viennagrid { namespace result_of { \
    template <typename ConfigType> \
    struct bndcell_orientation<ConfigType, arg_TAG, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Convenience macro for disabling local orientation storage for boundary k-cells of dimension arg_DIM for a n-cell identified by arg_TAG for all configuration classes.

#define VIENNAGRID_GLOBAL_DISABLE_DOMAIN_NCELL (   arg_DIM  ) 
Value:
namespace viennagrid { namespace result_of { \
    template <typename ConfigType> \
    struct bndcell_handling<ConfigType, domain_t<ConfigType>, arg_DIM> { \
      typedef no_handling_tag    type; \
    }; \
 } }

Disable the storage of n-cells for the domain for all configuration classes. Requires disabled storage of boundary n-cells.

#define VIENNAGRID_GLOBAL_DISABLE_NCELL_ID (   arg_TAG  ) 
Value:
namespace viennagrid { namespace result_of { \
    template <typename ConfigType> \
    struct element_id_handler<ConfigType, arg_TAG> { \
      typedef pointer_id    type; \
    }; \
 } }

Convenience macro for disabling the storage of an ID for a n-cell identified by arg_TAG for all configuration classes.

#define VIENNAGRID_GLOBAL_ENABLE_ALL_NCELL_ID_FOR_DATA (  ) 
Value:
namespace viennadata { namespace config { \
    template <typename ConfigType, typename CellTag> struct object_identifier<viennagrid::element_t<ConfigType, CellTag> >  { \
      typedef object_provided_id    tag; \
      typedef size_t                id_type; \
      static size_t get(viennagrid::element_t<ConfigType, CellTag> const & obj) { return obj.id(); } \
    };  }  }

Enable the use of the n-cell ID for ViennaData for all n-cells and all configuration classes. Required for dense storage with ViennaData.

#define VIENNAGRID_GLOBAL_ENABLE_NCELL_ID_FOR_DATA (   arg_CELLTAG  ) 
Value:
namespace viennadata { namespace config { \
    template <typename ConfigType> struct object_identifier<viennagrid::element_t<ConfigType, arg_CELLTAG> >  { \
      typedef object_provided_id    tag; \
      typedef size_t                id_type; \
      static size_t get(viennagrid::element_t<ConfigType, arg_CELLTAG> const & obj) { return obj.id(); } \
    };  }  }

Enable the use of the n-cell ID for ViennaData for n-cells identified by the tag arg_CELLTAG, irrespective of the configuration class. Required for dense storage with ViennaData.