variabledofspace.hpp

Go to the documentation of this file.

#ifndef VARIABLEDOFSPACE_HPP
#define VARIABLEDOFSPACE_HPP
 
#include<mesh.hpp>
 
namespace HArDCore2D
{
 
  class VariableDOFSpace {
  public:
    VariableDOFSpace(
             const Mesh & mesh,
             const Eigen::VectorXd n_local_vertex_dofs,
             const Eigen::VectorXd n_local_edge_dofs,
             const Eigen::VectorXd n_local_cell_dofs
             );
 
    VariableDOFSpace(
             const Mesh & mesh,
             size_t n_local_vertex_dofs,
             const Eigen::VectorXd n_local_edge_dofs,
             const Eigen::VectorXd n_local_cell_dofs
             );
 
    VariableDOFSpace(
             const Mesh & mesh,
             size_t n_local_vertex_dofs,
             size_t n_local_edge_dofs,
             const Eigen::VectorXd n_local_cell_dofs
             );
 
 
    VariableDOFSpace(
             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 size_t iV) const
    {
      assert(iV<m_mesh.n_vertices());
      return m_n_local_vertex_dofs[iV];
    }
    
    inline size_t numLocalDofsVertex(const Vertex & V) const
    {
      return numLocalDofsVertex(V.global_index());
    }
 
    inline size_t numLocalDofsEdge(const size_t iE) const
    {
      assert(iE<m_mesh.n_edges());
      return m_n_local_edge_dofs[iE];
    }
    
    inline size_t numLocalDofsEdge(const Edge & E) const
    {
      return numLocalDofsEdge(E.global_index());
    }
 
 
    inline size_t numLocalDofsCell(const size_t iT) const
    {
      assert(iT<m_mesh.n_cells());
      return m_n_local_cell_dofs[iT];
    }
 
    inline size_t numLocalDofsCell(const Cell & T) const
    {
      return numLocalDofsCell(T.global_index());
    }
 
    //------------------------------------------------------------------------------
    // Dimensions
    //------------------------------------------------------------------------------
    
   
    inline size_t nDOFs_vertices() const
    {
      return m_n_local_vertex_dofs.sum();
    }
   
    inline size_t nDOFs_edges() const
    {
      return m_n_local_edge_dofs.sum();
    }
 
 
    inline size_t nDOFs_cells() const
    {
      return m_n_local_cell_dofs.sum();
    }
 
    inline size_t dimension() const
    {
      return nDOFs_vertices() + nDOFs_edges() + nDOFs_cells();
    }
 
    //--- Vertices -----//
    inline size_t dimensionVertex(const Vertex & V) const
    {
      return m_n_local_vertex_dofs[V.global_index()];
    }
 
    inline size_t dimensionVertex(size_t iV) const
    {
      assert(iV<m_mesh.n_vertices());
      return dimensionVertex(*m_mesh.vertex(iV));
    }
 
    //--- Edges ----//
    inline size_t dimensionEdge(const Edge & E) const
    {
      return m_n_local_vertex_dofs[E.vertex(0)->global_index()] + m_n_local_vertex_dofs[E.vertex(1)->global_index()]
        + m_n_local_edge_dofs[E.global_index()];
    }
 
    inline size_t dimensionEdge(size_t iE) const
    {
      assert(iE<m_mesh.n_edges());
      return dimensionEdge(*m_mesh.edge(iE));
    }
 
    //--- Cell -----//
    inline size_t dimensionCell(const Cell & T) const
    {
      size_t nb_dofs = 0;
      for (Vertex * V : T.get_vertices()){
        nb_dofs += m_n_local_vertex_dofs[V->global_index()];
      }
      for (Edge * E : T.get_edges()){
        nb_dofs += m_n_local_edge_dofs[E->global_index()];
      }
      return nb_dofs + m_n_local_cell_dofs[T.global_index()];
    }
    
    inline size_t dimensionCell(size_t iT) const
    {
      return dimensionCell(*m_mesh.cell(iT));
    }
 
    //------------------------------------------------------------------------------
    // Local offsets
    //------------------------------------------------------------------------------
 
    inline size_t localOffset(const Edge & E, const Vertex & V) const
    {
      size_t nb_dofs = 0;
      for (int iV=0; iV<E.index_vertex(&V); iV++){
        nb_dofs += m_n_local_vertex_dofs[E.vertex(iV)->global_index()];
      }
      return nb_dofs;
    }
 
    inline size_t localOffset(const Edge & E) const
    {
      return m_n_local_vertex_dofs[E.vertex(0)->global_index()] + m_n_local_vertex_dofs[E.vertex(1)->global_index()];
    }
    
 
 
    inline size_t localOffset(const Cell & T, const Vertex & V) const
    {
      size_t nb_dofs = 0;
      for (int iV=0; iV<T.index_vertex(&V); iV++){
        nb_dofs += m_n_local_vertex_dofs[T.vertex(iV)->global_index()];
      }
      return nb_dofs;
    }
 
    inline size_t localOffset(const Cell & T, const Edge & E) const
    {
      size_t nb_dofs = 0;
      for (size_t iV=0; iV<T.n_vertices(); iV++){
        nb_dofs += m_n_local_vertex_dofs[T.vertex(iV)->global_index()];
      }
      for (int iE=0; iE<T.index_edge(&E); iE++){
        nb_dofs += m_n_local_edge_dofs[T.edge(iE)->global_index()];
      }
      return nb_dofs;
    }
 
    inline size_t localOffset(const Cell & T) const
    {
      size_t nb_dofs = 0;
      for (size_t iV=0; iV<T.n_vertices(); iV++){
        nb_dofs += m_n_local_vertex_dofs[T.vertex(iV)->global_index()];
      }
      for (size_t iE=0; iE<T.n_edges(); iE++){
        nb_dofs += m_n_local_edge_dofs[T.edge(iE)->global_index()];
      }
      return nb_dofs;
    }
 
    //------------------------------------------------------------------------------
    // Global offsets
    //------------------------------------------------------------------------------
    
    inline size_t globalOffset(const Vertex & V) const
    {
      return ( m_n_local_vertex_dofs.head(V.global_index()) ).sum();
    }
 
    inline size_t globalOffset(const Edge & E) const
    {
      return m_n_local_vertex_dofs.sum()
          + ( m_n_local_edge_dofs.head(E.global_index()) ).sum();
    }
 
 
    inline size_t globalOffset(const Cell & T) const
    {
      return m_n_local_vertex_dofs.sum()
          + m_n_local_edge_dofs.sum()
          + ( m_n_local_cell_dofs.head(T.global_index()) ).sum();
    }
    
    //------------------------------------------------------------------------------
    // Restrictions
    //------------------------------------------------------------------------------
 
    Eigen::VectorXd restrictEdge(size_t iE, 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 Cell & T, const Eigen::VectorXd vh) const
    {
      return restrictCell(T.global_index(), vh);
    }
    
    //------------------------------------------------------------------------------
    // Extensions
    //------------------------------------------------------------------------------
 
 
    Eigen::MatrixXd extendOperator(const Cell & T, const Edge & E, const Eigen::MatrixXd & opE) const;
 
    //------------------------------------------------------------------------------
    // Global DOF indices for an element T
    //------------------------------------------------------------------------------
 
    std::vector<size_t> globalDOFIndices(const Cell & T) const;
    std::vector<size_t> globalDOFIndices(const Edge & E) const; 
 
    
    private:
    const Mesh & m_mesh;
    Eigen::VectorXd m_n_local_vertex_dofs;
    Eigen::VectorXd m_n_local_edge_dofs;
    Eigen::VectorXd m_n_local_cell_dofs;
 
      
  };
 
} // namespace HArDCore2D
 
#endif