NAME

       reference_element - reference element

SYNOPSYS

       The  reference_element  class  defines all supported types of geometrical elements in one,
       two and three dimensions. The set of supported elements are designate by a letter

       p      point (dimension 0)

       e      edge (dimension 1)

       t      triangle(dimension 2)

       q      quadrangle(dimension 2)

       T      tetrahedron(dimension 3)

       P      prism(dimension 3)

       H      hexaedron(dimension 3)

IMPLEMENTATION

       class reference_element {
       public:

       // typedefs:

           typedef std::vector<int>::size_type size_type;

           // defines variant_type { p, t, q ..., H, ...};
           // in an automatically generated file :

           typedef size_type variant_type;
           static const variant_type
               p = 0,
               e = 1,
               t = 2,
               q = 3,
               T = 4,
               P = 5,
               H = 6,
               max_variant = 7;

       // allocators/deallocators:

           reference_element (variant_type x = max_variant)
             : _x(x) { assert_macro (x >= 0 && x <= max_variant, "invalid type " << x); }

       // initializers:

           void set_variant (variant_type x) { _x = x; }
           void set_variant (size_type n_vertex, size_type dim) { _x = variant (n_vertex, dim); }
           void set_name    (char name);

       // accessors:

           variant_type variant() const { return _x; }
           char name() const { return _name[_x]; }
           size_type dimension() const { return _dimension[_x]; }
           size_type size() const { return _n_vertex[_x]; }
           size_type n_subgeo(size_type subgeo_dim) const { return n_subgeo (variant(), subgeo_dim); }
           size_type n_edge() const { return n_subgeo(1); }
           size_type n_face() const { return n_subgeo(2); }
           size_type subgeo_size (size_type subgeo_dim, size_type loc_isid) const {
               return subgeo_n_node (_x, 1, subgeo_dim, loc_isid); }
           size_type subgeo_local_vertex(size_type subgeo_dim, size_type loc_isid, size_type loc_jsidvert) const {
               return subgeo_local_node (_x, 1, subgeo_dim, loc_isid, loc_jsidvert); }

           // TODO: use template<class T> instead of Float
           const point_basic<Float>& vertex (size_type iloc) const;
           friend Float measure (reference_element hat_K);
           Float side_measure (size_type loc_isid) const;
           void side_normal (size_type loc_isid, point_basic<Float>& hat_n) const;

       // helpers:

           static variant_type variant  (char name);
           static variant_type variant  (size_type n_vertex, size_type dim);
           static char         name     (variant_type variant) { return _name     [variant]; }
           static size_type dimension   (variant_type variant) { return _dimension[variant]; }
           static size_type n_vertex    (variant_type variant) { return _n_vertex [variant]; }
           static size_type n_node      (variant_type variant, size_type order);

           static size_type n_sub_edge    (variant_type variant);
           static size_type n_sub_face    (variant_type variant);
           static size_type n_subgeo      (variant_type variant, size_type subgeo_dim);
           static size_type subgeo_n_node (variant_type variant, size_type order, size_type subgeo_dim, size_type loc_isid);
           static size_type subgeo_local_node (variant_type variant, size_type order, size_type subgeo_dim, size_type loc_isid, size_type loc_jsidnod);

           static variant_type first_variant_by_dimension (size_type dim) {
                       return _first_variant_by_dimension[dim]; }
           static variant_type  last_variant_by_dimension (size_type dim) {
                       return _first_variant_by_dimension[dim+1]; }

           static size_type first_inod_by_variant (variant_type variant, size_type order, variant_type subgeo_variant);
           static size_type  last_inod_by_variant (variant_type variant, size_type order, variant_type subgeo_variant)
              { return first_inod_by_variant (variant, order, subgeo_variant+1); }
           static size_type first_inod (variant_type variant, size_type order, size_type subgeo_dim)
              { return first_inod_by_variant (variant, order, first_variant_by_dimension(subgeo_dim)); }
           static size_type  last_inod (variant_type variant, size_type order, size_type subgeo_dim)
              { return first_inod_by_variant (variant, order,  last_variant_by_dimension(subgeo_dim)); }
           static void init_local_nnode_by_variant (size_type order, boost::array<size_type,reference_element::max_variant>& loc_nnod_by_variant);

       protected:
       // constants:

           static const char      _name [max_variant];
           static const size_type _dimension [max_variant];
           static const size_type _n_vertex [max_variant];
           static const variant_type _first_variant_by_dimension[5];

       // data:

           variant_type _x;
       };