dofspace.hpp

Go to the documentation of this file.

#ifndef DOFSPACE_HPP_INCLUDED
#define DOFSPACE_HPP_INCLUDED
 
#include "mesh.hpp"
 
namespace Manicore {
 
 
  template<size_t dimension>
  class DOFSpace {
    public:
      DOFSpace() {;}
      DOFSpace(Mesh<dimension> const * mesh ,std::array<size_t,dimension+1> nb_local_dof ) 
        : _mesh(mesh), _nb_local_dofs(nb_local_dof) {;}
 
      size_t numLocalDofs(size_t d ) const {return _nb_local_dofs[d];}
      size_t dimensionMesh() const;
      size_t dimensionCell(size_t d ,
                           size_t i_cell ) const;
 
      size_t localOffset(size_t d ,
                         size_t i_cell ) const;
 
      size_t localOffset(size_t d_boundary , 
                         size_t d , 
                         size_t i_bd_rel , 
                         size_t i_cell ) const;
      size_t globalOffset(size_t d ,
                          size_t i_cell ) const;
 
 
      Eigen::VectorXd restrict(size_t d , 
                               size_t i_cell , 
                               const Eigen::VectorXd & vh ) const;
 
      Eigen::MatrixXd extendOperator(size_t d_boundary , 
                                     size_t d , 
                                     size_t i_bd_global , 
                                     size_t i_cell , 
                                     const Eigen::MatrixXd & op ) const;
 
    private:
      const Mesh<dimension>* _mesh;
      std::array<size_t,dimension+1> _nb_local_dofs;
  };
 
  // ---------------------------------------------------------------------------------------------------------
  // Implementation
  // ---------------------------------------------------------------------------------------------------------
  template<size_t dimension>
  size_t DOFSpace<dimension>::dimensionMesh() const 
  {
    size_t rv = _mesh->n_cells(0)*_nb_local_dofs[0];
    for (size_t i = 1; i <= dimension; ++i) {
      rv += _mesh->n_cells(i)*_nb_local_dofs[i];
    }
    return rv;
  }
 
  template<size_t dimension>
  size_t DOFSpace<dimension>::dimensionCell(size_t d, size_t i_cell) const 
  {
    size_t rv = _nb_local_dofs[d];
    for (size_t i = 0; i < d; ++i) {
      rv += _mesh->get_boundary(i,d,i_cell).size()*_nb_local_dofs[i];
    }
    return rv;
  }
 
  template<size_t dimension>
  size_t DOFSpace<dimension>::localOffset(size_t d, size_t i_cell) const 
  {
    size_t rv = 0;
    for (size_t i = 0; i < d; ++i) {
      rv += _mesh->get_boundary(i,d,i_cell).size()*_nb_local_dofs[i];
    }
    return rv;
  }
 
  template<size_t dimension>
  size_t DOFSpace<dimension>::localOffset(size_t d_boundary, size_t d, size_t i_bd_rel, size_t i_cell) const 
  {
    assert(d_boundary < d || i_bd_rel == 0);
    size_t rv = i_bd_rel*_nb_local_dofs[d_boundary];
    for (size_t i = 0; i < d_boundary; ++i) {
      rv += _mesh->get_boundary(i,d,i_cell).size()*_nb_local_dofs[i];
    }
    return rv;
  }
 
  template<size_t dimension>
  size_t DOFSpace<dimension>::globalOffset(size_t d, size_t i_cell) const 
  {
    size_t rv = i_cell*_nb_local_dofs[d];
    for (size_t i = 0; i < d; ++i) {
      rv += _mesh->n_cells(i)*_nb_local_dofs[i];
    }
    return rv;
  }
 
} // end namespace
 
#endif