pec.hpp

Go to the documentation of this file.

#ifndef PEC_HPP
#define PEC_HPP
 
#include "dcell_integral.hpp"
 
#include <iostream>
 
namespace Manicore {
 
 
 
  template<size_t dimension> 
  class PEC {
    public:
      PEC(Mesh<dimension> const & mesh, 
                 int r, 
                 bool use_threads = true, 
                 std::array<int,dimension> const * dqr_p = nullptr, 
                 std::ostream & output = std::cout 
                 );
 
 
      double getTopScaling(size_t i_cell ) const {return _listScales[i_cell];}
 
      Eigen::MatrixXd get_mass(size_t k , size_t d ,size_t i_cell ) const; 
 
      Eigen::MatrixXd get_trace(size_t k , size_t d ,size_t i_cell , size_t j_bd ) const; 
 
      Eigen::MatrixXd get_starTrace(size_t k , size_t d ,size_t i_cell , size_t j_bd ) const; 
 
      // Getter for the generic operators matrices
 
      const Eigen::MatrixXd & get_diff(size_t l , size_t d ) const {return _list_diff[_cmp_ind(l,d)];}
 
      const Eigen::MatrixXd & get_Koszul(size_t l , size_t d ) const {return _list_Koszul[_cmp_ind(l,d)];}
 
      const Eigen::MatrixXd & get_diff_as_degr(size_t l , size_t d ) const {return _list_diff_as_degr[_cmp_ind(l,d)];}
 
      const Eigen::MatrixXd & get_trimmed(size_t l , size_t d ) const {return _list_trimmed[_cmp_ind(l,d)];}
 
      const Eigen::MatrixXd & get_reduced_Koszul_m1(size_t l , size_t d ) const {return _list_reduced_Koszul_m1[_cmp_ind(l,d)];}
 
    private:
      template<size_t d,size_t l> void _fill_lists();
      inline int _cmp_ind(size_t l, size_t d) const {return _dim_table[d-1]+l;}
 
      int _r;
      std::array<size_t,dimension+1> _dim_table;
      std::vector<Eigen::MatrixXd> _list_diff, // Image of dPL(r,l,d) inside PL(r-1,l+1,d)
                                   _list_Koszul, // Image of kPL(r,l,d) inside PL(r+1,l-1,d)
                                   _list_diff_as_degr, // Image of dPL(r,l,d) inside PL(r,l+1,d)
                                   _list_trimmed, // Image of PLtrimmed(r,l,d)
                                   _list_reduced_Koszul_m1; // Image of kPL(r-1,l,d)
      std::vector<double> _listScales;
      template<size_t _dimension,size_t _d>
      class dCellVariableList {
        private:
          std::vector<dCell_mass<_dimension,_d>> _mass;
          std::vector<dCell_traces<_dimension,_d>> _traces;
          dCellVariableList<_dimension,_d-1> _dCVL;
        public:
          template<size_t d> std::vector<dCell_mass<_dimension,d>> & mass() {
            if constexpr(d==_d) return _mass; 
            else return _dCVL.template mass<d>();
          }
          template<size_t d> std::vector<dCell_mass<_dimension,d>> mass() const {
            if constexpr(d==_d) return _mass; 
            else return _dCVL.template mass<d>();
          }
          template<size_t d> std::vector<dCell_traces<_dimension,d>> & traces() {
            if constexpr(d==_d) return _traces; 
            else return _dCVL.template traces<d>();
          }
          template<size_t d> std::vector<dCell_traces<_dimension,d>> traces() const {
            if constexpr(d==_d) return _traces; 
            else return _dCVL.template traces<d>();
          }
      };
 
      template<size_t _dimension>
      class dCellVariableList<_dimension,1> {
        private:
          std::vector<dCell_mass<_dimension,1>> _mass;
          std::vector<dCell_traces<_dimension,1>> _traces;
        public:
          template<size_t d> std::vector<dCell_mass<_dimension,d>> & mass() {
            static_assert(d == 1);
            return _mass; 
          }
          template<size_t d> std::vector<dCell_mass<_dimension,d>> mass() const {
            static_assert(d == 1);
            return _mass; 
          }
          template<size_t d> std::vector<dCell_traces<_dimension,d>> & traces() {
            static_assert(d == 1);
            return _traces; 
          }
          template<size_t d> std::vector<dCell_traces<_dimension,d>> traces() const {
            static_assert(d == 1);
            return _traces; 
          }
      };
 
      dCellVariableList<dimension,dimension> _dCellList;
  };
}
#endif