prism(7rheolef) [debian man page]

prism(7rheolef) 						    rheolef-6.1 						   prism(7rheolef)

NAME

       prism - Prism reference element

DESCRIPTION

       The prism reference element is

	       K = { 0 < x < 1 and 0 < y < 1-x and -1 < z < 1 }

NUMBERING

       The  orientation  is  such that triedra (01, 02, 03) is direct and all faces, see from exterior, are in the direct sens.  References: P. L.
       Georges, "Generation automatique de maillages", page 24-, coll RMA, 16, Masson, 1994.

		   z

		   3 ---- 5
		'  | .	  |
	     4 .  '|	  |
	     |	   |	  |
	     |	   |	  |
	     |	   0 . . .2	y
	     |	'    .
	     1 .  '

	   x

IMPLEMENTATION

       const size_t dimension = 3;
       const Float  measure = 1;
       const size_t n_vertex = 6;
       const Float vertex [n_vertex][dimension] = {
	       { 0, 0,-1 },
	       { 1, 0,-1 },
	       { 0, 1,-1 },
	       { 0, 0, 1 },
	       { 1, 0, 1 },
	       { 0, 1, 1 } };
       const size_t  n_face = 5;
       const size_t face [n_face][4] = {
	       { 0, 2, 1, size_t(-1) },
	       { 3, 4, 5, size_t(-1) },
	       { 0, 1, 4, 3 },
	       { 1, 2, 5, 4 },
	       { 0, 3, 5, 2 } };
       const size_t  n_edge = 9;
       const size_t edge [n_edge][2] = {
	       { 0, 1 },
	       { 1, 2 },
	       { 2, 0 },
	       { 0, 3 },
	       { 1, 4 },
	       { 2, 5 },
	       { 3, 4 },
	       { 4, 5 },
	       { 5, 3 } };

rheolef-6.1							    rheolef-6.1 						   prism(7rheolef)

reference_element(7rheolef)					    rheolef-6.1 				       reference_element(7rheolef)

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 ele-
       ments 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); }

       // accessors:

	   variant_type variant() const { return _x; }
	   char name() const { return _name[_x]; }
	   size_type dimension() const { return _dimension[_x]; }
	   friend Float measure (reference_element hat_K);
	   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); }

	   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);

       // 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;
       };

rheolef-6.1							    rheolef-6.1 				       reference_element(7rheolef)