globaldofspace.hpp

Go to the documentation of this file.

#ifndef GLOBALDOFSPACE_HPP
#define GLOBALDOFSPACE_HPP
 
#include <localdofspace.hpp>
 
namespace HArDCore3D
{
 
  class GlobalDOFSpace : public LocalDOFSpace {
  public:
    GlobalDOFSpace(
             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
             );
 
    //------------------------------------------------------------------------------
    // Global offsets
    //------------------------------------------------------------------------------
    
    inline size_t globalOffset(const Vertex & V) const
    {
      return V.global_index() * m_n_local_vertex_dofs;
 
    }
 
    inline size_t globalOffset(const Edge & E) const
    {
      return m_mesh.n_vertices() * m_n_local_vertex_dofs
        + E.global_index() * m_n_local_edge_dofs;
    }
 
    inline size_t globalOffset(const Face & F) const
    {
      return m_mesh.n_vertices() * m_n_local_vertex_dofs
        + m_mesh.n_edges() * m_n_local_edge_dofs
        + F.global_index() * m_n_local_face_dofs;
    }
 
    inline size_t globalOffset(const Cell & T) 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
        + T.global_index() * m_n_local_cell_dofs;
    }
 
    inline size_t globalOffset(size_t d,size_t i) const 
    {
      size_t rv = i*numLocalDofs(d);
      switch(d) {
        case(3):
          rv += m_mesh.n_faces() * m_n_local_face_dofs;
        case(2):
          rv += m_mesh.n_edges() * m_n_local_edge_dofs;
        case(1):
          rv += m_mesh.n_vertices() * m_n_local_vertex_dofs;
        default:
          ;
      }
      return rv;
    }
    
    //------------------------------------------------------------------------------
    // Restrictions
    //------------------------------------------------------------------------------
 
    Eigen::VectorXd restrictEdge(size_t iE, const Eigen::VectorXd & vh) const;
 
    Eigen::VectorXd restrictFace(size_t iF, const Eigen::VectorXd & vh) const;
 
    Eigen::VectorXd restrictCell(size_t iT, const Eigen::VectorXd & vh) const;
 
    inline Eigen::VectorXd restrict(const Edge & E, const Eigen::VectorXd vh) const
    {
      return restrictEdge(E.global_index(), vh);
    }
 
    inline Eigen::VectorXd restrict(const Face & F, const Eigen::VectorXd vh) const
    {
      return restrictFace(F.global_index(), vh);
    }
 
    inline Eigen::VectorXd restrict(const Cell & T, const Eigen::VectorXd vh) const
    {
      return restrictCell(T.global_index(), vh);
    }
    
    //------------------------------------------------------------------------------
    // Extensions
    //------------------------------------------------------------------------------
 
    Eigen::MatrixXd extendOperator(const Cell & T, const Face & F, const Eigen::MatrixXd & opF) const;
 
    Eigen::MatrixXd extendOperator(const Cell & T, const Edge & E, const Eigen::MatrixXd & opE) const;
 
    Eigen::MatrixXd extendOperator(const Face & F, const Edge & E, const Eigen::MatrixXd & opE) const;
 
    Eigen::MatrixXd extendOperator(size_t d1, size_t i1, size_t d2, size_t i2, const Eigen::MatrixXd & op) const;
 
    void addInnerProductContribution(const Cell & T, const Face & F, Eigen::MatrixXd & prodT, const Eigen::MatrixXd & prodF) const;
 
    //------------------------------------------------------------------------------
    // Global DOF indices for an element T
    //------------------------------------------------------------------------------
 
    std::vector<size_t> globalDOFIndices(const Cell & T) const;
 
    std::vector<size_t> globalDOFIndices(const Face & F) const;    
  };
 
} // namespace HArDCore3D
 
#endif