ddr_spaces.hpp

Go to the documentation of this file.

#ifndef DDR_SPACES_HPP
#define DDR_SPACES_HPP
 
#include "dofspace.hpp"
#include "pec.hpp"
 
#include <memory>
#include <iostream>
 
namespace Manicore {
 
 
 
  template<size_t dimension>
  class DDR_Spaces {
    public:
      DDR_Spaces(Mesh<dimension> const & mesh, 
                 int r, 
                 bool use_threads = true, 
                 std::array<int,dimension> const * dqr_p = nullptr, 
                 std::ostream & output = std::cout 
                 );
 
 
      template<size_t k>
      using FunctionType = std::function<Eigen::Vector<double,Dimension::ExtDim(k,dimension)>(size_t map_id, const Eigen::Vector<double,dimension> &)>;
 
 
      template<size_t k >
      Eigen::VectorXd interpolate(FunctionType<k> const & func, 
                                  std::array<int,dimension> const * dqr_p = nullptr ) const;
 
 
      const Eigen::MatrixXd & full_diff(size_t k , size_t d ,size_t i_cell ) const // Return \star d in PL(r,d-k-1,d)
      {
        assert(d <= dimension && k < d && i_cell < _ops[d].size() && "Access of diff out of range");
        return _ops[d][i_cell].full_diff[k];
      }
 
      Eigen::MatrixXd compose_diff(size_t k , size_t d ,size_t i_cell ) const; 
 
      const Eigen::MatrixXd & potential(size_t k , size_t d ,size_t i_cell ) const // Return \star P^k in PL(r,d-k,d)
      {
        assert(d <= dimension && k <= d && i_cell< _ops[d].size() && "Access of potential out of range");
        return _ops[d][i_cell].P[k];
      }
 
      DOFSpace<dimension> const & dofspace(size_t k) const {
        return _dofspace[k];
      }
      const Mesh<dimension>* mesh() const {return _mesh;}
      int degree() const {return _r;}
 
 
      Eigen::MatrixXd computeL2Product(size_t k ,size_t i_cell ) const;
 
      double hmax() const;
 
    private:
      struct DDR_Operators { // one for each form degree k
        std::array<Eigen::MatrixXd,dimension+1> full_diff; // equal to \star d, PL(r,d-k-1,d) valued
        std::array<Eigen::MatrixXd,dimension+1> diff; // equal to \star \ul{d}, PLtrimmed(r,d-k-1,d) valued
        std::array<Eigen::MatrixXd,dimension+1> P; // equal to \star P, PL(r,d-k,d) valued
      };
 
      const Mesh<dimension>* _mesh;
      int _r;
      bool _use_threads;
      std::unique_ptr<PEC<dimension>> _ddr, _ddr_po;
      std::array<DOFSpace<dimension>,dimension+1> _dofspace; // one for all form degree
      std::array<std::vector<DDR_Operators>,dimension+1> _ops; // one for each cell dimension
  };
}
#endif