Program Listing for File mesh.h

↰ Return to documentation for file (src/rlenvs/utils/geometry/mesh/mesh.h)

#ifndef MESH_H
#define MESH_H

#include "rlenvs/rlenvs_types_v2.h"
#include "rlenvs/rlenvs_consts.h"
#include "rlenvs/utils/filtered_iterator.h"
#include "rlenvs/utils/geometry/mesh/mesh_topology.h"
#include "rlenvs/utils/geometry/mesh/element_type.h"


#include "boost/noncopyable.hpp"

namespace rlenvscpp{
namespace utils{
namespace geom{

// forward declarations
template<int dim, typename T> class GeomPoint;

template<int spacedim>
class Mesh: private boost::noncopyable
{

public:

    typedef typename MeshTopology<spacedim>::edge_ptr_t edge_ptr_t;
    typedef typename MeshTopology<spacedim>::face_ptr_t face_ptr_t;
    typedef typename MeshTopology<spacedim>::cedge_ptr_t cedge_ptr_t;
    typedef typename MeshTopology<spacedim>::cface_ptr_t cface_ptr_t;

    typedef typename std::vector<Node<spacedim>* >::iterator node_iterator_impl;
    typedef typename std::vector<Node<spacedim>* >::const_iterator cnode_iterator_impl;

    typedef typename std::vector<Element<spacedim>* >::iterator element_iterator_impl;
    typedef typename std::vector<Element<spacedim>* >::const_iterator celement_iterator_impl;

    typedef typename std::vector<edge_ptr_t >::iterator edge_iterator_impl;
    typedef typename std::vector<edge_ptr_t >::const_iterator cedge_iterator_impl;

    typedef typename std::vector<face_ptr_t>::iterator face_iterator_impl;
    typedef typename std::vector<face_ptr_t>::const_iterator cface_iterator_impl;

    const static int dimension = spacedim;

    Mesh();

    virtual ~Mesh();


    void reserve_n_nodes(uint_t n){topology_.reserve_n_nodes(n);}
    void reserve_n_elements(uint_t n){topology_.reserve_n_elements(n);}
    void reserve_n_edges(uint_t n){topology_.reserve_n_edges(n);}
    void reserve_n_faces(uint_t n){topology_.reserve_n_faces(n);}

    Node<spacedim>* create_vertex(const GeomPoint<spacedim, real_t>& point,
                                 uint_t global_id=rlenvscpp::consts::INVALID_ID,
                                 uint_t pid = 0);

    Node<spacedim>* create_node(const GeomPoint<spacedim, real_t>& point,
                               uint_t global_id=rlenvscpp::consts::INVALID_ID,
                               uint_t pid = 0);


    Element<spacedim>* create_element(ElementType::sub_type t,
                                     uint_t global_id=rlenvscpp::consts::INVALID_ID,
                                     uint_t pid = 0);


    edge_ptr_t  create_edge(ElementType::sub_type t,
                         uint_t global_id=rlenvscpp::consts::INVALID_ID,
                         uint_t pid = 0);


    face_ptr_t create_face(ElementType::sub_type t,
                       uint_t global_id=rlenvscpp::consts::INVALID_ID,
                       uint_t pid=0);


    void set_n_boundaries(uint_t nb){n_boundaries_ = nb;}


    Node<spacedim>* node(uint_t n){return topology_.node(n);}


    const Node<spacedim>* node(uint_t n)const{return topology_.node(n);}

    Element<spacedim>* element(uint_t e){return topology_.element(e);}


    const Element<spacedim>* element(uint_t e)const{return topology_.element(e);}


    uint_t n_vertices()const;

    uint_t n_nodes()const{return topology_.n_nodes();}


    uint_t n_elements()const{return topology_.n_elements();}

    uint_t n_edges()const;

   uint_t n_faces()const;


    uint_t n_active_faces()const;

    MeshTopology<spacedim>* topology(){return &topology_;}

    const MeshTopology<spacedim>* topology()const{return &topology_;}

    void faces(const MeshConnectivity& faces_idx,std::vector<cface_ptr_t>& faces_ptr)const
    {topology_.faces(faces_idx,faces_ptr);}

    uint_t n_boundaries()const{return n_boundaries_;}

    node_iterator_impl nodes_begin(){return topology_.nodes_begin();}
    node_iterator_impl nodes_end(){return topology_.nodes_end();}

    cnode_iterator_impl nodes_begin()const{return topology_.nodes_begin();}
    cnode_iterator_impl nodes_end()const{return topology_.nodes_end();}

    element_iterator_impl elements_begin(){return topology_.elements_begin();}
    element_iterator_impl elements_end(){return topology_.elements_end();}

    celement_iterator_impl elements_begin()const{return topology_.elements_begin();}
    celement_iterator_impl elements_end()const{return topology_.elements_end();}

    edge_iterator_impl edges_begin(){return topology_.edges_begin();}
    edge_iterator_impl edges_end(){return topology_.edges_end();}

    cedge_iterator_impl edges_begin()const{return topology_.edges_begin();}
    cedge_iterator_impl edges_end()const{return topology_.edges_end();}

    face_iterator_impl faces_begin(){return topology_.faces_begin();}
    face_iterator_impl faces_end(){return topology_.faces_end();}

    cface_iterator_impl faces_begin()const{return topology_.faces_begin();}
    cface_iterator_impl faces_end()const{return topology_.faces_end();}

private:

    uint_t n_boundaries_;

    MeshTopology<spacedim> topology_;
};


template<int spacedim>
inline
uint_t
Mesh<spacedim>::n_edges()const{
    return topology_.n_edges();
}

template<int spacedim>
inline
uint_t
Mesh<spacedim>::n_faces()const{
    return topology_.n_faces();
}

template<>
inline
uint_t
Mesh<1>::n_edges()const{
    return n_vertices();
}

template<>
inline
uint_t
Mesh<1>::n_faces()const{
    return n_edges();
}

}
}
}

#endif // MESH_H