localdofspace.hpp

Go to the documentation of this file.

#ifndef LOCALDOFSPACE_HPP
#define LOCALDOFSPACE_HPP
 
#include <mesh.hpp>
//#include <vertex.hpp>
//#include <edge.hpp>
//#include <cell.hpp>
 
namespace HArDCore2D {
 
 
  class LocalDOFSpace {
  public:
    LocalDOFSpace(
                  const Mesh & mesh,
                  size_t n_local_vertex_dofs,
                  size_t n_local_edge_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 numLocalDofsCell() const
    {
      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_cells() * m_n_local_cell_dofs;
    }
 
    inline size_t numTotalDofsVertices() const
    {
      return m_mesh.n_vertices() * m_n_local_vertex_dofs;
    }
 
    inline size_t numTotalDofsEdges() const
    {
      return m_mesh.n_edges() * m_n_local_edge_dofs;
    }
 
    inline size_t numTotalDofsCells() const
    {
      return 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 dimensionCell(const Cell & T) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_dofs
        + m_n_local_cell_dofs;
    }
 
    inline size_t dimensionCellBoundary(const Cell & T) const
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_dofs;
    }
    
    inline size_t dimensionCell(size_t iT) const
    {
      return dimensionCell(*m_mesh.cell(iT));
    }
 
    inline size_t dimensionCellBoundary(size_t iT) const
    {
      return dimensionCellBoundary(*m_mesh.cell(iT));
    }
    
    //------------------------------------------------------------------------------
    // 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 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
    {
      return T.n_vertices() * m_n_local_vertex_dofs
        + T.n_edges() * m_n_local_edge_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_cell_dofs;
  };
  
 
} // namespace HArDCore2D
#endif