mesh.h

Go to the documentation of this file.

#ifndef MESH_H
#define MESH_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
#include "bitrl/utils/filtered_iterator.h"
#include "bitrl/utils/geometry/mesh/element_type.h"
#include "bitrl/utils/geometry/mesh/mesh_topology.h"
 
#include "boost/noncopyable.hpp"
 
namespace bitrl
{
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 = bitrl::consts::INVALID_ID, uint_t pid = 0);
 
    Node<spacedim> *create_node(const GeomPoint<spacedim, real_t> &point,
                                uint_t global_id = bitrl::consts::INVALID_ID, uint_t pid = 0);
 
    Element<spacedim> *create_element(ElementType::sub_type t,
                                      uint_t global_id = bitrl::consts::INVALID_ID, uint_t pid = 0);
 
    edge_ptr_t create_edge(ElementType::sub_type t, uint_t global_id = bitrl::consts::INVALID_ID,
                           uint_t pid = 0);
 
    face_ptr_t create_face(ElementType::sub_type t, uint_t global_id = bitrl::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(); }
 
} // namespace geom
} // namespace utils
} // namespace bitrl
 
#endif // MESH_H