localdofspace.hpp

Go to the documentation of this file.

#ifndef LOCALDOFSPACE_HPP
#define LOCALDOFSPACE_HPP
 
#include <mesh.hpp>
 
namespace HArDCore3D {
 
 
  class LocalDOFSpace {
  public:
    LocalDOFSpace(
             const Mesh & mesh,
             size_t n_local_vertex_dofs,
             size_t n_local_edge_dofs,
             size_t n_local_face_dofs,
             size_t n_local_cell_dofs
             );
 
    //------------------------------------------------------------------------------
    // Accessors
    //------------------------------------------------------------------------------
    
    const Mesh & mesh() const
    {
      return m_mesh;
    }
 
    inline size_t numLocalDofsVertex() const
    {
      return m_n_local_vertex_dofs;
    }
    
    inline size_t numLocalDofsEdge() const
    {
      return m_n_local_edge_dofs;
    }
    
    inline size_t numLocalDofsFace() const
    {
      return m_n_local_face_dofs;
    }
    
    inline size_t numLocalDofsCell() const
    {
      return m_n_local_cell_dofs;
    }
 
    inline size_t numLocalDofs(size_t d) const 
    {
      assert(d < 4);
      if (d == 0) {
        return m_n_local_vertex_dofs;
      } else if (d == 1) {
        return m_n_local_edge_dofs;
      } else if (d == 2) {
        return m_n_local_face_dofs;
      } else {
        return m_n_local_cell_dofs;
      }
    }
    
    //------------------------------------------------------------------------------
    // Dimensions
    //------------------------------------------------------------------------------
    
    inline size_t dimension() const
    {
      return m_mesh.n_vertices() * m_n_local_vertex_dofs
        + m_mesh.n_edges() * m_n_local_edge_dofs
        + m_mesh.n_faces() * m_n_local_face_dofs
        + m_mesh.n_cells() * m_n_local_cell_dofs;
    }
 
    inline size_t dimensionVertex(const Vertex & V) const
    {
      return m_n_local_vertex_dofs;
    }
 
    inline size_t dimensionVertex(size_t iV) const
    {
      return dimensionVertex(*m_mesh.vertex(iV));
    }
 
    inline size_t dimensionEdge(const Edge & E) const
    {
      return 2 * m_n_local_vertex_dofs
        + m_n_local_edge_dofs;
    }
 
    inline size_t dimensionEdge(size_t iE) const
    {
      return dimensionEdge(*m_mesh.edge(iE));
    }
 
    inline size_t dimensionFace(const Face & F) const
    {
      return F.n_vertices() * m_n_local_vertex_dofs
        + F.n_edges() * m_n_local_edge_dofs
        + m_n_local_face_dofs;
    }
    
    inline size_t dimensionFace(size_t iF) const
    {
      return dimensionFace(*m_mesh.face(iF));
    }
 
    inline size_t dimensionCell(const Cell & T) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_dofs
        + T.n_faces() * m_n_local_face_dofs
        + m_n_local_cell_dofs;
    }
    
    inline size_t dimensionCell(size_t iT) const
    {
      return dimensionCell(*m_mesh.cell(iT));
    }
 
    inline size_t dimension(size_t d, size_t i) const 
    {
      assert(d < 4);
      if (d == 0) {
        return dimensionVertex(i);
      } else if (d == 1) {
        return dimensionEdge(i);
      } else if (d == 2) {
        return dimensionFace(i);
      } else {
        return dimensionCell(i);
      }
    }
 
    //------------------------------------------------------------------------------
    // Local offsets
    //------------------------------------------------------------------------------
 
    inline size_t localOffset(const Edge & E, const Vertex & V) const
    {
      return E.index_vertex(&V) * m_n_local_vertex_dofs;
    }
 
    inline size_t localOffset(const Edge & E) const
    {
      return 2 * m_n_local_vertex_dofs;
    }
    
    inline size_t localOffset(const Face & F, const Vertex & V) const
    {
      return F.index_vertex(&V) * m_n_local_vertex_dofs;
    }
 
    inline size_t localOffset(const Face & F, const Edge & E) const
    {
      return F.n_vertices() * m_n_local_vertex_dofs
        + F.index_edge(&E) * m_n_local_edge_dofs; 
    }
 
    inline size_t localOffset(const Face & F) const
    {
      return F.n_vertices() * m_n_local_vertex_dofs
        + F.n_edges() * m_n_local_edge_dofs;
    }
 
    inline size_t localOffset(const Cell & T, const Vertex & V) const
    {
      return T.index_vertex(&V) * m_n_local_vertex_dofs;
    }
 
    inline size_t localOffset(const Cell & T, const Edge & E) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.index_edge(&E) * m_n_local_edge_dofs;
    }
 
    inline size_t localOffset(const Cell & T, const Face & F) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_dofs
        + T.index_face(&F) * m_n_local_face_dofs;
    }
 
    inline size_t localOffset(const Cell & T) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_dofs
        + T.n_faces() * m_n_local_face_dofs;
    }
 
  protected:
    const Mesh & m_mesh;
    size_t m_n_local_vertex_dofs;
    size_t m_n_local_edge_dofs;
    size_t m_n_local_face_dofs;
    size_t m_n_local_cell_dofs;
  };
  
 
} // namespace HArDCore3D
#endif