Provided by: librheolef-dev_5.93-2_i386 bug

NAME

       geo_element - element of a mesh

DESCRIPTION

       Defines  geometrical  elements  and  sides as a set of vertice and edge
       indexes.  This element is obtained after a Piola transformation from  a
       reference  element  (see .  reference_element internal}').  Indexes are
       related to arrays of edges and vertices.  These arrays are included  in
       the  description  of  the mesh.  Thus, this class is related of a given
       mesh instance (see geo(3)).

EXAMPLE

       This is the test of geo_element:

           geo_element K;
           K.set_name('t') ;
           cout << "n_vertices: " << K.size()      << endl
                << "n_edges   : " << K.n_edges()   << endl
                << "dimension : " << K.dimension() << endl << endl;
           for(geo_element::size_type i = 0; i < K.size(); i++)
               K[i] = i*10 ;
           for(geo_element::size_type i = 0; i < K.n_edges(); i++)
               K.set_edge(i, i*10+5) ;
           cout << "vertices: local -> global" << endl;
           for (geo_element::size_type vloc = 0; vloc < K.size(); vloc++)
               cout << vloc << "-> " << K[vloc] << endl;
           cout << endl
                << "edges: local -> global" << endl;
           for (geo_element::size_type eloc = 0; eloc < K.n_edges(); eloc++) {
               geo_element::size_type vloc1 = subgeo_local_vertex(1, eloc, 0);
               geo_element::size_type vloc2 = subgeo_local_vertex(1, eloc, 1);
               cout << eloc << "-> " << K.edge(eloc) << endl
                    << "local_vertex_from_edge(" << eloc
                    << ") -> (" << vloc1 << ", " << vloc2 << ")" << endl;
           }

IMPLEMENTATION

       class geo_element : public reference_element {
       public:

       // allocators/deallocators:

           geo_element(enum_type t = max_size);
           geo_element(const geo_element&);
           explicit geo_element (const class tiny_element&);
           void copy (const geo_element&);
           void copy (const class tiny_element&);
           geo_element& operator = (const geo_element&);
           ~geo_element();

       // accessors:

           size_type index() const;
           size_type operator [] (size_type i) const;
           size_type side(size_type i_side) const;
           void build_side(size_type i_side, geo_element& S) const;

           size_type edge (size_type i_edge) const;
           size_type face (size_type i_face) const;

           size_type subgeo(const geo_element& S) const;
           size_type subgeo (size_type subgeo_dim, size_type i_subgeo) const;
           size_type subgeo_vertex (size_type subgeo_dim, size_type i_subgeo,
                                  size_type i_subgeo_vertex) const;
           void build_subgeo(size_type subgeo_dim, size_type i_subgeo, geo_element& S) const;
           size_type subgeo_local_index(const geo_element& S) const;

       // modifiers:

           void set_type (enum_type t);
           void set_type (size_type sz, size_type dim);
           void set_name (char      name);

           void set_index(size_type idx);
           size_type& operator [] (size_type i);
           void set_side (size_type i_side, size_type idx);

           void set_edge (size_type i_edge, size_type idx);
           void set_face (size_type i_face, size_type idx);
           void set_subgeo (size_type subgeo_dim, size_type i_subgeo,
                                  size_type idx);
           void set_subgeo(const geo_element& S, size_type idx);

       // inputs/outputs:

           friend std::istream& operator >> (std::istream&, geo_element&);
           friend std::ostream& operator << (std::ostream&, const geo_element&);
           std::ostream& dump(std::ostream& s = std::cerr) const;
           void check() const;

       // data:
       protected:
           size_type *_heap;

       // memory management:
           void _heap_init();
           void _heap_close();
       };

SEE ALSO

       geo(3)