Feel++  0.91.4
Classes | Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes
Feel::Hypercube< Dim, Order, RDim > Class Template Reference
Inheritance diagram for Feel::Hypercube< Dim, Order, RDim >:
Feel::Convex< Dim, Order, RDim > Feel::ConvexBase Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >

List of all members.

Classes

struct  faces_t
struct  PolyDims
struct  shape

Public Types

typedef mpl::at< elements_t,
mpl::int_< nDim > >::type 
element_type
typedef mpl::at< typename
faces_t< real_dimension >
::type, mpl::int_< nDim >
>::type 
topological_face_type
typedef mpl::vector
< boost::none_t, details::line
< orderSquare >, details::quad
< orderSquare >, details::hexa
< orderSquare > > 
map_entity_to_point_t
typedef mpl::at
< map_entity_to_point_t,
mpl::int_< nDim > >::type 
edge_to_point_t
typedef mpl::at
< map_entity_to_point_t,
mpl::int_< nDim > >::type 
face_to_point_t
typedef mpl::at
< map_entity_to_point_t,
mpl::int_< nDim > >::type 
face_to_edge_t
typedef no_permutation vertex_permutation_type
typedef mpl::if_
< mpl::greater_equal
< mpl::int_< nDim >, mpl::int_
< 2 > >, mpl::identity
< line_permutations >
, mpl::identity
< no_permutation >
>::type::type 
edge_permutation_type
typedef mpl::if_
< mpl::equal_to< mpl::int_
< nDim >, mpl::int_
< 3 > >, mpl::identity
< quadrangular_faces >
, mpl::identity
< no_permutation >
>::type::type 
face_permutation_type
typedef mpl::if_
< mpl::equal_to< mpl::int_
< nDim >, mpl::int_
< 2 > >, mpl::identity
< edge_permutation_type >
, typename mpl::if_
< mpl::equal_to< mpl::int_
< nDim >, mpl::int_
< 3 > >, mpl::identity
< face_permutation_type >
, mpl::identity
< no_permutation > >::type >
::type::type 
permutation_type

Public Member Functions

uint16_type topologicalDimension () const
uint16_type dimension () const

Static Public Member Functions

static uint16_type nPointsOnVertex ()
static uint16_type nPointsOnEdge ()
static uint16_type nPointsOnFace ()
static uint16_type nPointsOnVolume ()
static uint32_type polyDims (int n)
static int e2p (int e, int p)
static int f2e (int f, int e)
static int f2p (int f, int p)
static std::string name ()
static std::string type ()

Static Public Attributes

static const bool is_simplex = false
static const bool is_hypercube = true
static const size_type Shape = mpl::at<shapes_t, mpl::int_<Dim> >::type::value
static const size_type Geometry = mpl::at<geometries_t, mpl::int_<Dim> >::type::value
static const uint16_type nDim = Dim
static const uint16_type nOrder = Order
static const uint16_type nRealDim = RDim
static const uint16_type topological_dimension = nDim
static const uint16_type real_dimension = RDim
static const uint16_type numVertices = mpl::at<vertices_t, mpl::int_<Dim> >::type::value
static const uint16_type numEdges = mpl::at<edges_t, mpl::int_<Dim> >::type::value
static const uint16_type numFaces = mpl::at<geo_faces_index_t, mpl::int_<Dim> >::type::value
static const uint16_type numGeometricFaces = mpl::at<geo_faces_index_t, mpl::int_<nDim> >::type::value
static const uint16_type numTopologicalFaces = mpl::at<faces_index_t, mpl::int_<nDim> >::type::value
static const uint16_type numNormals = mpl::at<normals_t, mpl::int_<nDim> >::type::value
static const uint16_type numVolumes = mpl::at<volumes_t, mpl::int_<nDim> >::type::value
static const uint16_type nbPtsPerVertex = (nOrder==0)?0:1
static const uint16_type nbPtsPerEdge = (nOrder==0)?((nDim==1)?1:0):mpl::at<points_edge_t, mpl::int_<nDim> >::type::value
static const uint16_type nbPtsPerFace = (nOrder==0)?((nDim==2)?1:0):mpl::at<points_face_t, mpl::int_<nDim> >::type::value
static const uint16_type nbPtsPerVolume = (nOrder==0)?((nDim==3)?1:0):mpl::at<points_volume_t, mpl::int_<nDim> >::type::value
static const uint16_type numPoints
static const uint16_type orderSquare

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
class Feel::Hypercube< Dim, Order, RDim >


Member Function Documentation

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
uint16_type Feel::Hypercube< Dim, Order, RDim >::dimension ( ) const [inline]
Returns:
the dimension of the space where the simplex resides

Reimplemented in Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >.

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static int Feel::Hypercube< Dim, Order, RDim >::e2p ( int  e,
int  p 
) [inline, static]

Given an edge e in the element and the local index p (0 or 1) of a point in the edge e ,

Returns:
the index in the element of the point.
template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static int Feel::Hypercube< Dim, Order, RDim >::f2e ( int  f,
int  e 
) [inline, static]

Given a face f in the element and the local index e of an edge in the face f,

Returns:
the index in the element of the edge.
template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static int Feel::Hypercube< Dim, Order, RDim >::f2p ( int  f,
int  p 
) [inline, static]

Given a face f in the element and the local index p of a point in the face f ,

Returns:
the index in the element of the point.
template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static std::string Feel::Hypercube< Dim, Order, RDim >::name ( ) [inline, static]
Returns:
the name of the simplex product
template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static uint16_type Feel::Hypercube< Dim, Order, RDim >::nPointsOnEdge ( ) [inline, static]

Returns the number of points per edge

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static uint16_type Feel::Hypercube< Dim, Order, RDim >::nPointsOnFace ( ) [inline, static]

Returns the number of points per face

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static uint16_type Feel::Hypercube< Dim, Order, RDim >::nPointsOnVertex ( ) [inline, static]

Returns the number of points per vertex

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
static uint16_type Feel::Hypercube< Dim, Order, RDim >::nPointsOnVolume ( ) [inline, static]

Returns the number of points per volume

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
uint16_type Feel::Hypercube< Dim, Order, RDim >::topologicalDimension ( ) const [inline]
Returns:
the topological dimension of the simplex

Reimplemented in Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >.


Member Data Documentation

template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
const uint16_type Feel::Hypercube< Dim, Order, RDim >::numPoints [static]
Initial value:
 ( numVertices * nbPtsPerVertex +
                                           numEdges * nbPtsPerEdge +
                                           numFaces * nbPtsPerFace +
                                           numVolumes * nbPtsPerVolume )
template<uint16_type Dim, uint16_type Order = 1, uint16_type RDim = Dim>
const uint16_type Feel::Hypercube< Dim, Order, RDim >::orderSquare [static]
Initial value:
 boost::mpl::if_<boost::mpl::greater< boost::mpl::int_<Order>,
                                                                                boost::mpl::int_<5> >,
                                                           boost::mpl::int_<5>,
                                                           typename boost::mpl::if_<boost::mpl::less< boost::mpl::int_<Order>,
                                                                                                      boost::mpl::int_<1> >,
                                                                                    boost::mpl::int_<1>,
                                                                                    boost::mpl::int_<Order>
                                                                                    >::type
                                                                                    >::type::value